 NEXT-INACTIVE UP PREVIOUS

         N NTRODUCTION TO ROGRAMMING -64 EMOS

               UTERMAN
              PUTERMAN@CIVITAS64.DE
               AKA INUS KERLUND

ONTENTS

  * ONTENTS
  * NTRODUCTION
     * HAT IS THIS OCUMENT BOUT?
     * HY ID  RITE HIS OCUMENT?
     * ONTRIBUTORS
  * HY -64 EMOS?
     * HY EMOS?
     * HY -64
  * EARNING ACHINE ANGUAGE
     * LASHING THE ORDER
  * OOLS
     * SING A ONITOR
     * SING AN SSEMBLER
     * ROSS SSEMBLERS AND MULATORS
  * EMO ROGRAMMING
     * $D012
  * RAPHICS
     * PRITES
     * HARACTER RAPHICS
     * ITMAP RAPHICS
  * NTERRUPTS
     * HY NTERRUPTS
     * HAT IS AN NTERRUPT?
     * OW TO MPLEMENT NTERRUPTS
     * LAYING MUSIC AGAIN
     * SING ORE HAN NE NTERRUPT ER RAME
     * TABLE ASTER NTERRUPTS
     * S
  * NTERESTING FFECTS
     * EXT CROLLER
     * ASTER ARS
     * PENING THE OP AND OTTOM ORDER
     * 
     * PRITE ULTIPLEXER
     * ECH-TECH
     * , ,  ETC.
     * PENING THE IDE ORDER
     * LASMAS, UMPMAPPERS, 3D EFFECTS
     * HE EST
     * N XERCISE
  * OOLS
     * ARTRIDGES
     * ACKERS AND RUNCHERS
     *  LOADERS
     * PRITE, HAR, RAPHICS EDITORS
     * INE EDITORS ETC.
     * USIC EDITORS
     * EXT DITORS AND CROLL EXT RITERS
     * OTERS
     * THER OOLS
  * OMMON ITFALLS
     * INAL ARTRIDGE
     * RAPHICS AT $1000 OR $9000
     * ARBAGE IN ERTICAL ORDER OR EHIND 
     * VERYTHING ORKS NTIL  ACK T!
  *  EW ORDS BOUT PTIMIZATION
     * HAT TO PTIMIZE
     * OW TO PTIMIZE OMPUTATIONS
     * THER AYS TO AKE ODE ASTER
  * THER OCUMENTS
     * EFERENCES
     * AGAZINES WITH UTORIALS
     * S
  * ONTACTING THE UTHOR
     * OPYING THIS DOCUMENT
  * BOUT THIS DOCUMENT ...

               NTRODUCTION

HAT IS THIS OCUMENT BOUT?

 HIS IS A DOCUMENT ABOUT CODING DEMOS ON THE -64. ITH THE ADDITIONAL
 HELP OF SOME REFERENCES, YOU SHOULD BE ABLE TO LEARN HOW TO CODE DEMOS BY
 READING THIS DOCUMENT AND WRITING SOME CODE.

HY ID  RITE HIS OCUMENT?

 HERE WERE SEVERAL THINGS THAT GOT ME STARTED WRITING THIS DOCUMENT. IRST
 OF ALL,  DIDN'T KNOW OF ANY GOOD TUTORIAL ABOUT DEMO PROGRAMMING ON THE
 -64. HERE'S ODERS ORLD, OF COURSE, BUT IT MAY NOT BE THOROUGH ENOUGH
 WITH THE INITIAL DETAILS. FTER ALL, THE HARDEST PROBLEM IS TO GET STARTED
 AT ALL.

 NOTHER REASON WAS THAT PEOPLE SOMETIMES ASK ME THINGS ABOUT CODING, SO IN
 A WAY THIS IS ALSO SOME KIND OF AN . OT THAT 'VE BEEN ASKED ABOUT ALL
 THESE THINGS, OF COURSE, 'VE FILLED IN QUITE A LOT OF GAPS.

 HE MOST IMPORTANT REASON, THOUGH, IS THAT  WANT PEOPLE TO LEARN TO CODE
 DEMOS ON THE -64, AND IF THE AVAILABILITY OF A DOCUMENT LIKE THIS CAN
 MAKE SOMEONE START CODING, THAT'D MAKE ME VERY HAPPY. HE -64 SCENE IS
 SLOWLY FADING INTO OBLIVION, WITH FEWER AND FEWER RELEASES, AND  THINK
 WHAT'S MISSING THE MOST IS A NEW GENERATION OF CODERS WHO WANT TO ASTONISH
 PEOPLE WITH AMAZING EFFECTS. ND IF YOU WANT TO DO THAT, YOU HAVE TO START
 SOMEWHERE, AND THAT SOMEWHERE IS, IN MY OPINION, NOT WITH 8X8 PLASMAS, BUT
 WITH THE KINDS OF EFFECTS THAT  GO THROUGH IN THIS TUTORIAL.

 'M NOT CLAIMING TO BE A GOOD CODER. OT EVEN AN AVERAGE ONE. UT  KNOW
 SOME OF THE BASICS, AND 'M TRYING TO SHARE THAT KNOWLEDGE HERE.

ONTRIBUTORS

 HANKS TO LACKACK FOR READING THROUGH THE TEXT AND SUGGESTING CHANGES.

               HY -64 EMOS?

 EFORE WE START PROGRAMMING WE SHOULD PROBABLY ASK OURSELVES TWO
 QUESTIONS:

  * HY PROGRAM DEMOS?
  * HY USE THE -64?

HY EMOS?

 T'S PRETTY OBVIOUS WHY YOU'D WANT TO PROGRAM DEMOS; BECAUSE IT'S FUN. OU
 GET ALL THE USUAL ADVANTAGES OF DOING PROGRAMMING, THAT YOU'RE LEARNING
 ABOUT PROGRAMMING AND THAT IT'S FUN. OU ALSO GET THE ADDED ADVANTAGE THAT
 THE RESULTING PROGRAMS ARE COOL AND NICE TO LOOK AT (IF YOU'RE GOOD AT
 IT). ND OF COURSE, DEMOS IS MORE FUN THAN MOST OTHER THINGS YOU CAN
 PROGRAM.

 NOTHER GOOD THING ABOUT PROGRAMMING DEMOS IS THAT YOU'LL LEARN ABOUT MANY
 DIFFERENT ASPECTS OF THE COMPUTER, AT A VERY LOW LEVEL. O GET GOOD
 PERFORMANCE (WHICH IS VERY IMPORTANT IN DEMOS), YOU NEED TO WRITE
 EFFICIENT CODE, AND THE ONLY WAY TO DO THAT IS TO BANG DIRECTLY ON THE
 HARDWARE. OU DON'T USE ANY KIND OF LIBRARIES OR ABSTRACTIONS WHEN YOU
 PROGRAM DEMOS, YOU DO IT ALL THE HARD WAY. O YOU NEED TO UNDERSTAND HOW
 YOU MAKE GRAPHICS APPEAR ON THE SCREEN, MUSIC TO BE HEARD FROM THE
 SPEAKERS AND HOW TO LOAD STUFF FROM DISK.

 OU ALSO NEED TO USE INTERRUPTS, WHICH IS SOMETHING YOU REALLY NEED TO
 KNOW ABOUT IF YOU'RE EVER GOING TO WRITE AN OPERATING SYSTEM. T IS ALSO
 ONE OF THE THINGS THAT IS CONSIDERED TO BE DIFFICULT TO UNDERSTAND. ON'T
 LET THAT SCARE YOU, THOUGH, IT'S A PRETTY EASY PRINCIPLE TO UNDERSTAND,
 AND AS SOON AS YOU'VE GOTTEN IT TO WORK ONCE, YOU CAN PROBABLY DO IT MUCH
 MORE EASILY THE NEXT TIME.

 LL IN ALL, IN CODING DEMOS YOU LEARN HOW A COMPUTER WORKS AT A VERY
 FUNDAMENTAL LEVEL, AND UNDERSTANDING THAT MAKES LOTS OF OTHER THINGS IN
 PROGRAMMING EASIER. 'LL JUST TAKE ONE EXAMPLE: NOVICE  PROGRAMMERS OFTEN
 HAVE LOTS OF PROBLEMS WITH POINTERS. ELL, IF YOU'VE WRITTEN SOME MACHINE
 CODE PROGRAMS YOU KNOW WHAT POINTERS ARE AND THAT THEY'RE NOT DANGEROUS1.

HY -64

 HE SECOND QUESTION  POSED ABOVE WAS WHY YOU'D WANT TO PROGRAM YOUR DEMOS
 ON A -64. HERE ARE NUMEROUS VERY GOOD REASONS WHY YOU SHOULD USE A -64,
 SOME OF WHICH ARE APPLICABLE TO SOME OTHER HARDWARE PLATFORMS AS WELL, AND
 SOME WHICH AREN'T. 'LL LIST SOME OF MY FAVOURITE REASONS HERE.

 HE 

 HE  IN THE -64 IS A 6510, WHICH IS A VARIANT OF THE 6502. T'S A VERY
 NICE PROCESSOR TO PROGRAM. T HAS A SIMPLE INSTRUCTION SET, SO IT'S EASY
 TO GET STARTED. T HAS BEEN STUDIED A LOT AND THERE'S LOTS OF
 DOCUMENTATION AVAILABLE. T USES MEMORY MAPPED /, WHICH MEANS THAT
 PERFORMING / (LIKE SHOWING STUFF ON THE SCREEN) IS NO DIFFERENT THAN
 PUTTING A VALUE AT SOME ARBITRARY MEMORY LOCATION.

 F COURSE, THE 6502 ONLY HAS THREE REGISTERS (NOT COUNTING THE ,  AND
 TATUS REGISTER), WHICH CAN MAKE IT A PAIN IN THE ASS TO IMPLEMENT
 COMPLICATED ALGORITHMS ON, BUT ON THE OTHER HAND, IT SURE MAKES YOU
 APPRECIATE A MODERN  PROCESSOR WITH DOZENS OF GENERAL-PURPOSE
 REGISTERS.

 HE 

 HE  (THE GRAPHICS CHIP) IS VERY NICE. HE  HAS A LOT OF INTERESTING
 BUGS (OR FEATURES, DEPENDING ON HOW YOU LOOK AT IT), WHICH MEANS YOU CAN
 CREATE AMAZING EFFECTS THAT ARE UNIQUE TO THE -64. T'S ALL ABOUT
 LEARNING ABOUT THE HARDWARE AND LEARNING HOW TO USE IT TO FIT YOUR NEEDS,
 NOT JUST BLINDLY FOLLOWING A SPECIFICATION DOCUMENT.

 OST OF THESE EFFECTS ARE ACHIEVED THROUGH WELL-TIMED MODIFICATIONS OF 
 REGISTERS. HAT'S ONE OF THE THINGS ARE MOST IMPORTANT IN DEMO PROGRAM: TO
 USE PERFECTLY TIMED CODE. REATING RASTER BARS ON THE MIGA IS EASY: JUST
 PUT SOME VALUES IN THE COPPER LIST. N THE -64, ON THE OTHER HAND, YOU
 HAVE TO CHANGE $D020 AND/OR $D021 AT EXACTLY THE RIGHT TIME, OR YOU'LL GET
 FLICKERING BARS.

 T'S LD AND LOW

 HAT THE -64 IS OLD AND SLOW MIGHT NOT SOUND LIKE MUCH OF AN ADVANTAGE,
 BUT WHEN IT COMES TO DEMO PROGRAMMING, IT IS. HY? T MEANS THAT IT'S
 DIFFICULT TO DO STUFF THAT REQUIRES LOTS OF COMPUTATIONS. OU CAN'T JUST
 THROW  CYCLES AT IT, AND WRITE INEFFICIENT CODE. OU HAVE TO THINK, TO
 MAKE IT EFFICIENT. ND DOING REALLY DIFFICULT THINGS (OR RATHER,
 IMPOSSIBLE THINGS) IS WHAT DEMO PROGRAMMING IS ALL ABOUT.  GOOD
 PROGRAMMER CAN WRITE A PROGRAM THAT DOES SOMETHING THAT SEEMS VERY HARD TO
 DO.  GOOD DEMO PROGRAMMER CAN WRITE CODE THAT DOES SOMETHING THAT IS
 COMPLETELY IMPOSSIBLE.

 HAT'S WHY IT'S MEANINGLESS TO START WRITING DEMOS ON A MODERN COMPUTER:
 IT'S TOO EASY TO MAKE STUFF THAT LOOKS IMPRESSIVE, IT'S TOO EASY TO FOOL
 PEOPLE INTO THINKING THAT YOU'VE DONE SOMETHING IMPRESSIVE, SO YOU REALLY
 DON'T HAVE THE RIGHT SORT OF MOTIVATION TO ACTUALLY WRITE GOOD CODE.
 NSTEAD YOU'RE PUSHED IN ANOTHER DIRECTION, TOWARDS WRITING LARGE
 PROGRAMS, WHICH WILL REQUIRE THAT YOU USE ABSTRACTION, WHICH PROBABLY
 MEANS THAT YOU'LL USE SOME HIGH LEVEL LANGUAGE, AND THEN YOU'RE NOT EVEN
 CLOSE TO PROGRAMMING DEMOS.

 IGH LEVEL LANGUAGES ARE NICE, THEY MAKE IT EASY TO CREATE UTILITY
 PROGRAMS, AND MAKE THEM SECURE AND ROBUST. UT IF YOU'RE WRITING A PROGRAM
 THAT DISPLAYS GRAPHICS EFFECTS, THAT ARE WRITTEN IN A HIGH LEVEL LANGUAGE,
 DON'T TRY TO FOOL ANYONE THAT YOU'RE WRITING A DEMO.  DEMO IS NEVER
 WRITTEN IN A HIGH LEVEL LANGUAGE. 2

 HY AM  MAKING SUCH A STRONG POINT ABOUT THIS? ECAUSE A DEMO ISN'T A
 PROGRAM, IT'S SOMETHING ELSE. N WHAT WAY DOES A DEMO DIFFER FROM A
 PROGRAM?  DEMO HAS TO TAKE OVER THE COMPUTER AND BANG DIRECTLY ON THE
 HARDWARE, IT DOES NOT RUN UNDER AN OPERATING SYSTEM. HIS ALSO MEANS THAT
 IT WILL HAVE TO TAKE CARE OF THE THINGS THAT THE OPERATING SYSTEM WOULD
 TAKE CARE OF, IF YOU WERE WRITING A NORMAL PROGRAM, LIKE INTERRUPT
 HANDLING AND /.

 NYWAY,  SHOULDN'T SPEND TOO MUCH TIME ON THIS, JUST BELIEVE ME, IT'S
 MUCH BETTER TO LEARN TO PROGRAM THE -64, BEFORE YOU MOVE ON TO MORE
 MODERN3ARCHITECTURES. 'M NOT PUTTING THEM DOWN, A WORKSTATION IS GOOD FOR
 LOTS OF THINGS, AND  SPEND QUITE A LOT OF MY TIME WRITING CODE IN HIGH
 LEVEL LANGUAGES, BUT YOU CAN NEVER RUN A DEMO UNDER A REAL OPERATING
 SYSTEM. KAY, LET'S MOVE ON TO SOME ACTUAL PROGRAMMING.

             EARNING ACHINE ANGUAGE

 IRST OF ALL, YOU NEED TO LEARN 6502 ASSEMBLY LANGUAGE. 'M NOT GOING TO
 INCLUDE A TUTORIAL ON ASSEMBLER PROGRAMMING HERE. 'LL JUST GIVE A FEW
 EXAMPLES AND GIVE POINTERS TO SOME OTHER GOOD DOCUMENTS.

 'D SUGGEST YOU DO THE FOLLOWING TO LEARN ASSEMBLER: GET A TUTORIAL, AND
 TRY TO GRASP THE GENERAL STRUCTURE OF IT, LEARN SOME OF THE MORE IMPORTANT
 INSTRUCTIONS, AND THEN GET A GOOD REFERENCE, LIKE ''ROGRAMMER'S EFERENCE
 UIDE''. OU SHOULDN'T READ THE WHOLE BOOK, AS MOST OF IT EXPLAINS HOW TO
 PROGRAM THE -64 IN . UT THE SUMMARY OF THE OPCODES IS NICE, SO
 THAT'S A GOOD REASON TO KEEP THE BOOK.

 HERE'S A PRETTY NICE ASSEMBLER TUTORIAL IN THE FIRST COUPLE OF ISSUES OF
 OMMODORE ACKING.

 HEN YOU'VE LEARNED SOME ASSEMBLER, YOU NEED TO KNOW WHICH MEMORY
 ADDRESSES TO POKE VALUES INTO TO MAKE INTERESTING THINGS HAPPEN. S THE
 -64 USES MEMORY MAPPED /, YOU PERFORM / OPERATIONS JUST BY PUTTING
 VALUES INTO MEMORY LOCATIONS, OR READING FROM MEMORY LOCATIONS. HAT YOU
 NEED IS A MEMORY MAP, THAT TELLS YOU WHICH ADDRESSES ARE SPECIAL, AND
 WHICH ONES ARE JUST . ''APPING THE -64'' IS A NICE AND DETAILED
 MEMORY MAP.

 F YOU THINK YOU'RE REALLY SMART, YOU SHOULDN'T EVEN NEED A TUTORIAL ON
 ASSEMBLER, ALL YOU NEED IS A REFERENCE DOCUMENT AND SOME EXAMPLES. O
 LET'S LOOK AT SOME REALLY SIMPLE EXAMPLES.

LASHING THE ORDER

  VERY SIMPLE EFFECT, THAT SHOWS HOW YOU CAN ACHIEVE SOME THINGS ON THE
 -64, IS TO MAKE THE BORDER FLASH IN DIFFERENT COLOURS. ERE'S THE CODE TO
 DO IT4:

      * = $1000

 LOOP:      INC $D020 ; INCREMENT $D020
      JMP LOOP  ; JUMP TO LABEL LOOP

 HAT WAS A SHORT PROGRAM, WASN'T IT? F YOU TYPE IN AND RUN THIS PROGRAM5,
 YOU WILL SEE THE BORDER FLASHING WILDLY. F YOU'RE USING AN ASSEMBLER LIKE
 URBO SSEMBLER OR SSLASTER, YOU SHOULD JUST HAVE TO TAP THE  KEY
 TO GET BACK TO THE ASSEMBLER.

 ET'S EXPLAIN EXACTLY WHAT THE PROGRAM DOES. N THE FIRST LINE, WE SIMPLY
 TELL THE ASSEMBLER THAT THE MACHINE CODE IT CREATES SHOULD START AT MEMORY
 ADDRESS $1000 (1000 HEXADECIMAL, WHICH IS THE SAME AS 4096 IN THE DECIMAL
 NUMBER SYSTEM). HIS IS URBO SSEMBLER SYNTAX. F YOU'RE USING SOME OTHER
 ASSEMBLER, CONSULT THE DOCUMENTATION.

 HE SECOND LINE HAS A LABEL, LOOP, WHICH IS JUST A WAY TO NAME THAT MEMORY
 LOCATION, IE. THE ONE WHERE THE INSTRUCTION INC $D020 STARTS. S WE HAVE
 TOLD THE ASSEMBLER TO ASSEMBLE THE CODE TO ADDRESS $1000, WE KNOW THAT
 WHAT THE LABEL LOOP REPRESENTS IS ACTUALLY $1000.

 FTER THE LABEL COMES AN INSTRUCTION, INC $D020, WHICH TELLS MEANS
 ''INCREMENT WHATEVER VALUE IS AT THE ADDRESS $D020 IN PLACE''. HIS IS THE
 SAME THING AS LOADING THE VALUE FROM $D020 (USING THE INSTRUCTION LDA
 $D020), ADDING 1 TO IT (ADC #$01) AND THEN STORING IT IN THE SAME ADDRESS
 (STA $D020). HY DO WE DO THIS? ECAUSE THE -64 HAS MEMORY MAPPED /,
 AND THE ADRESS $D020 ACTUALLY REPRESENTS THE BORDER COLOUR. O BY PUTTING
 DIFFERENT VALUES IN $D020, WE CHANGE THE COLOUR OF THE BORDER. O IF IT
 WAS INITIALLY BLACK (VALUE 0), IT WILL BE WHITE (VALUE 1) AFTER EXECUTING
 THE INSTRUCTION INC $D020.

 HEN WE COME TO THE LAST LINE, WHICH SAYS JMP LOOP. HEN THE PROGRAM FLOW
 REACHES THIS LINE, IT JUMPS TO THE ADRESS CORRESPONDING TO THE LABEL LOOP
 AND KEEPS EXECUTING INSTRUCTIONS THERE. N OUR CASE, IT WILL JUMP BACK TO
 THE PREVIOUS LINE AND EXECUTE INC $D020 AGAIN. HEN IT WILL AGAIN REACH
 THE JMP LOOP LINE, GO BACK, INCREMENT THE BORDER COLOUR ETC., FOREVER. R
 RATHER, UNTIL WE PRESS , WHICH WILL TAKE US BACK TO THE ASSEMBLER,
 OR IF WE RESET THE COMPUTER OR WHATEVER.

 O, NOW YOU KNOW HOW TO FLASH THE BORDER. F YOU USE SOME OTHER ADDRESS
 THAN $D020, YOU CAN CHANGE OTHER THINGS. OME ADDRESSES WILL JUST GIVE
 WEIRD RESULTS, OTHERS WILL GIVE SANE RESULTS. F YOU USE $D021 INSTEAD OF
 $D020, THE MAIN SCREEN WILL FLASH INSTEAD.

 LEARING THE CREEN

 ET'S JUST TAKE ANOTHER SIMPLE EXAMPLE, THAT SHOWS SOME OTHER
 INSTRUCTIONS, AND ACTUALLY DOES SOMETHING USEFUL. HAT WE'LL DO IS TO
 CLEAR THE SCREEN. HAT MAY NOT SOUND VERY INTERESTING, BUT IT'S SOMETHING
 YOU'LL NEED TO DO AT THE BEGINNING OF MOST DEMO PARTS YOU WRITE, SO IT'S
 ACTUALLY USEFUL. ND OF COURSE, AFTER YOU HAVE CLEARED THE SCREEN, YOU CAN
 JUST JUMP TO SOME OTHER ROUTINE, LIKE EG. THE ONE THAT FLASHES THE BORDER.

 ERE'S THE CODE TO CLEAR THE SCREEN:

      * = $1000

      LDA #$00      ; UT THE VALUE 0 IN ACCUMULATOR
      STA $D020     ; UT VALUE OF ACC IN $D020
      STA $D021     ; UT VALUE OF ACC IN $D021
      TAX           ; UT VALUE OF ACC IN X REG
      LDA $20       ; UT THE VALUE $20 IN ACC
 CLRLOOP:   STA $0400,X   ; UT VALUE OF ACC IN $0400 + VALUE IN X REG
      STA $0500,X  
      STA $0600,X  
      STA $0700,X
      DEX            ; ECREMENT VALUE IN X REG
      BNE CLRLOOP    ; F NOT ZERO, BRANCH TO CLRLOOP

 O, HOW DOES THE PROGRAM ABOVE CLEAR THE SCREEN? HE COMMENTS SHOULD
 EXPLAIN MOST OF WHAT GOES ON, BUT HERE'S AN OVERVIEW:

  * E START BY SETTING THE BORDER AND ACKGROUND COLOURS TO BLACK. HE
   VALUE 0 MEANS BLACK, AND, AS YOU PROBABLY REMEMBER FROM THE LAST
   EXAMPLE, $D020 AND $D021 ARE THE ADDRESSES THAT CONTROL THE COLOUR OF
   THE BORDER AND THE MAIN SCREEN.

  * OW WE WANT TO REMOVE ALL THE CHARACTERS FROM SCREEN MEMORY. CREEN
   MEMORY IS BY DEFAULT LOCATED AT $0400, AND IS $400 BYTES LONG6, SO WE
   NEED A LOOP TO CLEAR IT ALL. E CLEAR IT BY SETTING EVERY CHARACTER
   POSITION TO $20, WHICH IS THE CHARACTER CODE FOR THE SPACE CHARACTER.

  * OTE HOW CLEVERLY WE HANDLE THE LOOP INDEX, IN THE  REGISTER. E
   START BY SETTING IT TO 0. HEN WE DECREMENT FOR EACH ITERATION AND
   THEN COMPARE IT SO 0. HE FIRST TIME WE DECREMENT IT, IT WILL WRAP
   AROUND TO $FF, AND THEN IT WILL GO ALL THE WAY DOWN TO 0 AGAIN.

 F THERE'S ANYTHING ABOUT THIS TEST PROGRAM THAT YOU DON'T UNDERSTAND,
 LOOK UP THE INSTRUCTIONS AND THE VARIOUS ADDRESSING MODES IN YOUR 6502
 ASSEMBLER REFERENCE.

 OTE THAT THIS PROGRAM WON'T BEHAVE VERY WELL IF YOU JUST TYPE IT IN AND
 RUN IT, BECAUSE IT DOESN'T REALLY END. FTER THE LOOP HAS FINISHED, IT
 WILL JUST HAPPILY GET WHATEVER IS AT THE ADDRESS AFTER THE LOOP AND TRY TO
 EXECUTE IT AS AN INSTRUCTION. HAT WILL PROBABLY NOT WORK VERY WELL, AND
 SOMETHING WEIRD WILL HAPPEN. OU WILL HAVE TO FIGURE OUT YOURSELF HOW TO
 MAKE IT BEHAVE. NE IDEA IS TO END THIS PROGRAM BY APPENDING THE BORDER
 FLASHING CODE FROM THE PREVIOUS EXAMPLE.

               OOLS

 EFORE WE JUMP STRAIGHT TO DEMO PROGRAMMING,  NEED TO INTRODUCE SOME
 TOOLS. HE NECESSARY TOOLS ARE A MONITOR AND/OR AN ASSEMBLER. OU CAN
 CHOOSE TO DO YOUR PROGRAMMING EITHER IN A MONITOR OR AN ASSEMBLER. HICH
 CHOICE IS THE BEST IS UP TO YOU. EOPLE HAVE DIFFERENT OPINIONS, BUT THESE
 DAYS MOST PEOPLE WOULD PROBABLY SAY THAT AN ASSEMBLER IS THE BEST CHOICE,
 BECAUSE IT MAKES PROGRAMMING MORE EASY, AS YOU CAN MOVE STUFF AROUND,
 INSERT CODE INTO ALREADY EXISTING CODE, ADD COMMENTS AND USE LABELS. N
 THE OTHER HAND, IF YOU PROGRAM IN A MONITOR, YOU KNOW EXACTLY WHERE IN
 MEMORY YOUR CODE IS AND YOU KNOW WHERE THE PAGE BORDERS ARE, SOMETHING
 WHICH IS REALLY IMPORTANT WHEN IT COMES TO WRITING CODE THAT NEEDS PERFECT
 TIMING.

 NYWAY, 'LL TRY TO DESCRIBE HOW YOU CAN DO SOME STUFF WITH A MONITOR AND
 WITH AN ASSEMBLER. LL THE EXAMPLE CODE IN THIS TEXT IS IN URBO SSEMBLER
 FORMAT, SO MAYBE IT'S EASIEST FOR YOU TO USE URBO SSEMBLER TO START
 WITH. HE REASON WHY  USE URBO SSEMBLER FORMAT IS THAT MOST PEOPLE IN
 THE SCENE USE URBO SSEMBLER, AND  USE IT MYSELF.

SING A ONITOR

 HE MONITOR 'LL DESCRIBE HERE IS A PRETTY STANDARDIZED ONE, AND THE
 COMMANDS DESCRIBED SHOULD WORK ON MOST MONITORS, LIKE THE ONES IN THE
 CTION EPLAY AND INAL ARTRIDGE CARTRIDGES. HERE ARE SOME EXCEPTIONS,
 LIKE -ON, AND IF THAT'S THE ONLY MONITOR YOU HAVE, YOU'LL HAVE TO FIND
 OUT HOW IT WORKS ON YOUR OWN.

 O WRITE NEW CODE, YOU TYPE IN A LINE LIKE

 .A 1000 LDA #$00

 HAT THIS DOES IS THAT IT ASSEMBLES THE INSTRUCTION LDA #$00 AND PUTS THE
 RESULTING MACHINE CODE AT THE ADDRESS $1000. OU CAN NOW SIMPLY TYPE THE
 NEXT LINE OF CODE, AS THE MONITOR ITSELF SHOULD NOW GIVE YOU A LINE THAT
 LOOKS LIKE THIS:

 .A 1002

 HAT IS, THE MONITOR ITSELF CALCULATES WHERE YOU WANT TO PUT THE NEXT
 INSTRUCTION, SO IF YOU WANT TO TYPE IN A WHOLE PROGRAM, YOU ONLY HAVE TO
 ISSUE THE A COMMAND ONCE YOURSELF.

 O START A PROGRAM, YOU SIMPLY JUMP DIRECTLY IT, USING THE G COMMAND, EG.:

 .G 1000

 HIS WILL JUMP DIRECTLY TO THE ADDRESS $1000. O LOOK AT THE CODE IN
 MEMORY, EG. THE CODE YOU'VE ALREADY WRITTEN, USE THE D COMMAND, LIKE THIS:

 .D 1000

 HIS WILL DISASSEMBLE THE CODE IN MEMORY, STARTING AT $1000. IFFERENT
 MONITORS WILL HANDLE THIS DIFFERENTLY, BUT MOST MONITORS SHOULD LET YOU
 SCROLL THROUGH THE CODE, USING THE CURSOR KEYS.

 HERE ARE LOTS OF MORE MONITOR COMMANDS, BUT THIS ISN'T A MANUAL FOR
 MACHINE CODE MONITORS, SO 'LL LEAVE THE REST TO YOU.

SING AN SSEMBLER

 EARNING TO USE AN ASSEMBLER MAY BE A BIT MORE DIFFICULT THAN LEARNING TO
 USE A MONITOR, BUT MOST PEOPLE WOULD PROBABLY THINK THAT IT'S EASIER TO
 USE AN ASSEMBLER THAN A MONITOR. HEN YOU'VE LOADED AND STARTED URBO
 SSEMBLER (SYS $9000), YOU END UP IN THE EDITOR, IN WHICH YOU WRITE CODE.
 HE SYNTAX IS JUST LIKE THE EXEMPLES IN THIS TEXT.

 OST COMMANDS IN URBO SSEMBLER ARE INVOKED BY PRESSING $ /LEFTARROW$,
 FOLLOWED BY SOME OTHER KEY. O ASSEMBLE A PROGRAM, USE $ /LEFTARROW$ - 3.
 HIS WILL ASSEMBLE THE PROGRAM, AND IF YOU PRESS S JUST AFTER THE
 ASSEMBLY, THE PROGRAM IS STARTED AUTOMATICALLY. HEN YOU'RE IN THE
 PROGRAM, YOU CAN GET BACK TO URBO SSEMBLER BY PRESSING 7. F THAT
 DOESN'T WORK, YOU CAN RESET AND TYPE SYS $9000, WHICH SHOULD BRING YOU
 BACK, UNLESS YOU'VE MANAGED TO OVERWRITE THE MEMORY OF URBO SSEMBLER.

 OME OTHER NICE COMMANDS ARE:

  * $ /LEFTARROW$ - 5 - ASSEMBLE TO OBJECT FILE ON DISK
  * $ /LEFTARROW$ - S - SAVE SOURCE TO DISK
  * $ /LEFTARROW$ - L - LOAD SOURCE FROM DISK
  * $ /LEFTARROW$ - 1 - EXIT TO BASIC

 HE REST YOU'LL HAVE TO FIGURE OUT FOR YOURSELF. HERE ARE DOCUMENTS
 AVAILABLE ON THE WEB ABOUT HOW TO USE URBO SSEMBLER. HERE ARE ALSO LOTS
 OF DIFFERENT VERSIONS FLOATING AROUND, SOME OF WHICH SUPPORT MACROS AND
 SOME OF WHICH SUPPORT UNDOCUMENTED OPCODES. OU CAN TRY DIFFERENT VERSIONS
 TO SEE WHICH ONE YOU LIKE BEST, BUT FOR NOW IT SHOULDN'T MATTER WHICH
 VERSION YOU USE.

ROSS SSEMBLERS AND MULATORS

 OU CAN ALSO USE A CROSS ASSEMBLER, WHICH IS A PROGRAM THAT DOES THE
 ASSEMBLY FOR YOU ON SOME OTHER COMPUTER, LIKE AN MIGA OR A , AND THEN
 YOU CAN TRANSFER THE MACHINE CODE TO YOUR -64 AND RUN IT.  DON'T KNOW
 TOO MUCH ABOUT CROSS ASSEMBLERS, SO  WON'T GO INTO THAT HERE.

 OU CAN ALSO RUN YOUR CODE IN AN EMULATOR (PREFERABLY ), INSTEAD OF ON
 A REAL -64. HIS ISN'T ANYTHING 'D RECOMMEND, AS YOU CAN NEVER BE SURE
 THAT THE EMULATOR WILL BE COMPLETELY COMPATIBLE WITH THE REAL THING.

               EMO ROGRAMMING

 INALLY, WE GET TO THE INTERESTING STUFF, IE. DEMO PROGRAMMING. OW, THERE
 ARE A LOT OF THINGS YOU NEED TO KNOW ABOUT IF YOU'RE GOING TO WRITE A
 DEMO, SO WE'LL HAVE TO DECIDE WHERE TO START.  DEMO CONSISTS OF GRAPHICS,
 SOUND AND CODE. F COURSE, IN THIS DOCUMENT WE'LL CONCENTRATE ON PRODUCING
 THE CODE, BUT YOU'LL STILL NEED TO KNOW HOW TO DISPLAY GRAPHICS AND PLAY
 SOUNDS.

 HE SOUND IN MOST DEMOS IS MUSIC, AND PLAYING MUSIC PRODUCED WITH SOME
 MUSIC EDITOR, LIKE  OR 'S EDITOR, IS VERY EASY. OU DON'T REALLY
 NEED TO MAKE THE MUSIC YOURSELF EITHER, YOU CAN ALWAYS USE SOMEONE ELSE'S
 MUSIC, AS LONG AS YOU GIVE CREDIT TO THE PERSON WHO DID THE MUSIC. 'LL
 SHOW YOU WHAT TO DO TO PLAY A TUNE IN AN EXAMPLE BELOW, BUT FIRST THERE
 ARE SOME BASIC CONCEPTS WE NEED TO COVER, LIKE SYNCHRONIZING THINGS WITH
 THE SCREEN REFRESH.

 S PLAYING MUSIC IS SO EASY (UNLESS YOU'RE GOING TO DO SOMETHING REALLY
 FANCY), WE'LL CONCENTRATE ON CODING GRAPHICS EFFECTS, BECAUSE THAT'S
 REALLY EVERYTHING YOU NEED IN A DEMO.

 F COURSE, IF YOU MAKE A MULTI-PART DEMO THAT CAN'T BE SQUEEZED INTO
 MEMORY, YOU'LL NEED TO LOAD PARTS FROM DISK. OU DON'T HAVE TO WRITE A
 LOADER YOURSELF, THOUGH, AS THERE ARE SOME VERY GOOD LOADERS AROUND
 ALREADY.

$D012

 RYPTIC HEADER, RIGHT? $D012 MIGHT BE THE MOST IMPORTANT ADDRESS OF THEM
 ALL, WHEN IT COMES TO DEMO PROGRAMMING ON THE -64. $D012 HAS TWO
 DIFFERENT FUNCTIONS:

  * HEN READ, IT RETURNS THE NUMBER OF THE CURRENT RASTER LINE.
  * HEN WRITTEN, IT IS USED TO SET THE NUMBER OF THE LINE WHERE THE NEXT
   RASTER INTERRUPT WILL OCCUR.

 E'LL GET BACK TO RASTER INTERRUPTS LATER. OU NEED TO KNOW ABOUT $D012 TO
 UNDERSTAND THEM, SO PAY ATTENTION TO THE STUFF IN THIS SECTION! HE FIRST
 ITEM ABOVE IS INTERESTING, BUT IT MAY NOT BE OBVIOUS WHY IT IS
 INTERESTING.

 HE CURRENT RASTER LINE IS THE LINE THAT IS CURRENTLY BEING REDRAWN ON
 YOUR SCREEN. HE WHOLE SCREEN IS REDRAWN 50 TIMES PER SECOND8. ACH TIME
 IT IS REDRAWN FROM TOP TO BOTTOM, FROM THE LEFT TO THE RIGHT. O, IF YOU
 WANT SOMETHING TO HAPPEN 50 TIMES PER SECOND, ALL YOU HAVE TO DO IS TO
 CHECK THE CURRENT VALUE OF $D012, AND WHEN IT REACHES A CERTAIN VALUE,
 CALL THE ROUTINE THAT PERFORMS THE DESIRED TASK. HEN FINISHED, GO BACK TO
 CHECKING $D012.

 OW, THERE ARE 318 RASTER LINES ON A  MACHINE, AND ONE REGISTER CAN
 ONLY STORE VALUES BETWEEN 0 AND 255, SO YOU NEED ANOTHER BIT TO REPRESENT
 ALL 318 LINES. HAT BIT IS BIT 7 OF $D011. O, BIT 7 OF $D011 IS REALLY
 BIT 8 OF $D012. OES THAT SOUND CONFUSING? N THAT CASE, READ THIS
 PARAGRAPH A COUPLE OF MORE TIMES. O, IF BIT 7 ON $D011 IS SET, $D012
 REPRESENTS RASTER LINES GREATER THAN 255 ($FF), OTHERWISE THE LINES
 BETWEEN 0 AND 255.

 F YOU WANT TO TAKE THE EASY WAY OUT, AND YOU DON'T NEED TO SYNCHRONIZE TO
 SOME SPECIFIC PART OF THE SCREEN, USE A $D012 VALUE GREATER THAN $40,
 BECAUSE $FF + $40 = $13F = 319. O YOU'LL NEVER GET A VALUE GREATER THAN
 $3F IF BIT 7 OF $D011 IS SET. 'LL SHOW HOW YOU CAN USE $D012 WITH AN
 EXAMPLE:

      * = $0801

      LDA #$00
      TAX
      TAY
      JSR $1000 ; INITIALIZE MUSIC

 MAINLOOP:  LDA $D012    ; LOAD $D012
      CMP #$80     ; IS IT EQUAL TO #$80?
      BNE MAINLOOP ; IF NOT, KEEP CHECKING

      INC $D020    ; INC BORDER COLOUR
      JSR $1003    ; JUMP TO MUSIC PLAY ROUTINE
      DEC $D020    ; DEC BORDER COLOUR
      JMP MAINLOOP ; KEEP LOOPING

 OW, BEFORE YOU TRY THIS PROGRAM OUT, YOU'LL NEED TO HAVE A TUNE LOADED
 INTO MEMORY AT $1000. OST TUNES USED IN DEMOS, INTROS AND WHAT HAVE YOU
 ARE LOCATED AT $1000, SO YOU JUST NEED TO RIP A TUNE, OR GET IT SOME OTHER
 WAY. HE CODE BEFORE THE MAINLOOP JUST INITIALIZES THE TUNE, IE. SETS ALL
 REGISTERS TO 0, AND THEN JUMPS TO THE INITIALIZATION ROUTINE. OU DON'T
 HAVE TO KNOW WHAT THE MUSIC ROUTINE DOES, BUT WHAT IT ACTUALLY DOES IS
 THAT IT RESETS THE REGISTERS OF THE  CHIP.

 FTER THE INITIALIZATION WE MOVE DIRECTLY INTO THE MAIN LOOP. HAT THE
 MAIN LOOP DOES IS THAT IT LOADS THE VALUE FROM $D012, COMPARES IT TO $80
 (128 DECIMAL, SOMEWHERE IN THE MIDDLE OF THE SCREEN), AND IF IT'S NOT $80,
 IT JUMPS BACK TO WHERE IT BEGAN, IE. TO LOADING THE VALUE FROM $D012.

 OW, AS SOON AS THE RASTER BEAM REACHES LINE $80, THE INNER LOOP IS
 EXITED, AND WE END UP AT THE LINE THAT SAYS INC $D020. HAT WE DO IS THAT
 WE INCREMENT THE BORDER COLOUR, JUMP TO THE MUSIC PLAY ROUTINE, WHICH
 EXECUTES AND RETURNS, AND THEN WE DECREMENT THE BORDER COLOUR AND JUMP
 BACK TO THE MAIN LOOP. HY DO WE CHANGE THE BORDER COLOUR? ECAUSE IT'S A
 WAY TO VISUALIZE HOW MUCH TIME THE MUSIC PLAYER ROUTINE TAKES. OU'LL
 ACTUALLY NOT ONLY SEE HOW MUCH TIME IT TAKES (IN RASTER LINES), BUT ALSO
 WHERE ON THE SCREEN YOU'RE PLAYING IT, IE. WHERE THE RASTER BEAM IS WHEN
 YOU'RE IN THE MUSIC PLAYER ROUTINE.

 N THIS EXAMPLE WE'VE LEARNED TWO THINGS:

  * HOW TO USE $D012 TO SYNCHRONIZE THINGS WITH THE SCREEN REFRESH, AND
  * HOW TO PLAY MUSIC.

 E WILL LATER SHOW THAT THIS MUSIC PLAYER ROUTINE IS IN NO WAY PERFECT,
 BUT IT'S A GOOD ILLUSTRATION OF SOME CONCEPTS, AND IT WORKS PRETTY WELL.
 OU SHOULD NOW BE ABLE TO FIGURE OUT FOR YOURSELF HOW TO DO RASTER BARS.
 HE TRICK IS THAT YOU WAIT FOR A CERTAIN RASTER LINE, THEN CHANGE THE
 BACKGROUND COLOUR (IF YOU'RE ON THE NORMAL SCREEN, YOU HAVE TO CHANGE BOTH
 $D020 AND $D021, IF YOU'RE IN THE UPPER OR LOWER BORDER, YOU ONLY HAVE TO
 CHANGE $D020). OU NEED PRETTY GOOD TIMING TO DO THAT, BUT WITH A
 HARDCODED DELAY BETWEEN THE COLOUR CHANGES, IT SHOULD WORK WELL WITH CODE
 SIMILAR TO THE ABOVE EXAMPLE.

               RAPHICS

 OW IT'S TIME TO MOVE ON TO SOME MORE INTERESTING STUFF, MAKING THINGS
 HAPPEN ON THE SCREEN. F COURSE, THINGS HAVE BEEN HAPPENING WITH THE
 SCREEN IN ALL THE ABOVE EXAMPLES, BUT NOT IN A VERY CONTROLLED WAY.

 O GET THINGS TO HAPPEN ON THE SCREEN, YOU NEED TO KNOW WHICH 
 REGISTERS TO PUT WHICH VALUES INTO. HERE'S ALSO THE SCREEN MEMORY, WHICH
 IS NORMALLY LOCATED AT $0400, AND THE COLOUR MEMORY, WHICH IS LOCATED AT
 $D800, AND WORKS LIKE THE SCREEN MEMORY, BUT DOESN'T CONTAIN CHARACTER
 CODES, BUT COLOUR VALUES OF THE CHARACTERS ON THE SCREEN. UT THE  IS
 THE MOST IMPORTANT THING, SO WE'LL START WITH SOME  BASICS.

PRITES

 PRITE ASICS

 PRITES CAN BE USED FOR LOTS OF COOL THINGS. HAT'S NICE ABOUT THEM IS
 THAT THEY CAN BE MOVED AROUND ON THE SCREEN, WITHOUT AFFECTING THE
 BACKGROUND. S YOU PROBABLY KNOW ALREADY, THE -64 HAS 8 HARDWARE SPRITES,
 SO YOU CAN HAVE 8 THINGS MOVING AROUND SIMULTANEOUSLY, OR SYNCHRONIZE
 THEIR MOVEMENT TO MAKE BIGGER OBJECTS MOVE AROUND THE SCREEN.

 OU PROBABLY KNOW THAT THERE ARE WAYS TO GET MORE THAN 8 SPRITES ON THE
 SCREEN, BUT WE'LL GO THROUGH THE BASICS BEFORE WE REVEAL THAT TRICK. HE
 BASICS OF SPRITES CONSIST OF THE FOLLOWING:

  * DISPLAYING THEM,
  * SETTING THEIR POSITION,
  * CHANGING THEIR SHAPE AND
  * CHANGING THEIR COLOUR.

 HERE ARE A NUMBER OF THINGS YOU NEED TO DO IN ORDER TO MAKE A SPRITE
 APPEAR ON THE SCREEN. OU NEED TO POINT IT AT A CHUNK OF DATA, THAT
 DEFINES WHAT IT SHOULD LOOK LIKE. HEN YOU NEED TO SET THE X AND Y
 COORDINATES. F COURSE, YOU PROBABLY ALSO WANT TO SET THE COLOUR OF THE
 SPRITE. ND, LAST BUT NOT LEAST, YOU NEED TO TURN THE SPRITE ON. HIS IS
 ALL THE STUFF THAT IS LISTED ABOVE, AND THIS IS EVERYTHING YOU NEED TO BE
 ABLE TO DO TO DO SOME BASIC SPRITE EFFECTS, LIKE MOVING THEM AROUND ON THE
 SCREEN, ANIMATING THEM, ETC.

 PRITE OINTERS

 HE SPRITE POINTERS, IE. THE ADRESSES THAT CONTAIN THE POINTERS TO WHERE
 THE GRAPHICS DATA THAT IS DISPLAYED ON THE SCREEN AS SPRITES, ARE LOCATED
 AFTER THE END OF THE SCREEN MEMORY, WHICH IS USUALLY LOCATED AT $0400. HE
 SCREEN MEMORY TAKES UP EXACTLY 1000 BYTES (40 TIMES 25 CHARACTERS), SO THE
 LAST 24 BYTES OF THE MEMORY FROM $0400 TO $0800 ARE FREE. HE LAST 8 ONES
 OF THESE ARE THE SPRITE POINTERS, AND THE 16 BYTES BEFORE THE SPRITE
 POINTERS AREN'T USED AT ALL, UNLESS 'M COMPLETELY MISTAKEN.

 O, THE BYTE AT $07F8 IS THE SPRITE POINTER FOR THE FIRST SPRITE. OW, HOW
 DO WE FIT A POINTER INTO ONE BYTE? O REPRESENT AN ADDRESS IN MEMORY, WE
 NEED TWO BYTES. UT SPRITE POINTERS ARE HANDLED IN A SPECIAL WAY. IRST OF
 ALL, YOU ONLY POINT TO SPRITE DATA THAT IS LOCATED IN THE SAME  BANK AS
 THE ONE WHERE YOU KEEP THE SCREEN MEMORY. HERE ARE FOUR  BANKS,
 $0000-$3FFF IS THE FIRST ONE, THE ONE THAT'S USED BY DEFAULT.  SPRITE
 TAKES UP 63 BYTES OF DATA, BUT HAVE TO BE ALIGNED TO 64 BYTES, SO YOU CAN
 PUT SPRITE DATA STARTING AT ADRESSES $0000, $0040, $0080, $00C0, $0100
 ETC.

 O, HOW MANY SPRITES CAN YOU FIT INTO ONE  BANK? 256. ND HOW MANY
 NUMBERS CAN A BYTE REPRESENT? 256. HA! OW WE CAN UNDERSTAND HOW THE
 SPRITE POINTERS WORK: IF YOU SET A SPRITE POINTER TO 0, IT WILL POIN TO
 THE ADDRESS $0000, IN THE CURRENT  BANK. F YOU SET IT TO 1, IT WILL
 POINT TO $0040. F YOU SET IT TO $80, IT WILL POINT TO $2000, AND IF YOU
 SET IT TO $C0, IT WILL POINT TO $3000. ASY, ISN'T IT? O, LET'S SAY YOU
 WANT TO DO A SIMPLE ANIMATION, CONSISTING OF 8 SPRITES, WITH THE SPRITE
 DATA PLACED AT $2000 (UP TO $21FF). OU START BY PUTTING THE VALUE $80
 INTO $07F8, THEN CHANGE IT TO $81, THEN $82, AND SO ON UP TO $87, THEN
 YOU'D START OVER FROM $80.

 MPORTANT DDRESSES

 OW WE MOVE ON TO HOW YOU SET COORDINATES AND COLOURS AND TURN ON SPRITES.
 URNING THE SPRITES ON IS SIMPLE. HE SPRITES ARE NUMBERED FROM 0 UP TO 7.
 HE SPRITE WHOSE POINTER YOU SET WHEN YOU POKE VALUES INTO $07F8 IS 0, THE
 ONE AT $07F9 IS 1, AND SO ON. OU TURN ON THE SPRITES BY SETTING THE
 CORRESPONDING BITS IN $D015. O, TO TURN ON SPRITE NUMBER 0, YOU POKE THE
 VALUE 1 INTO $D015. O TURN ON SPRITES 0 AND 1, PUT 3 IN $D015.

 ETTING THE COORDINATES OF THE SPRITES ARE EQUALLY SIMPLE, WITH ONE SMALL
 CATCH. HE X COORDINATE REGISTERS ARE $D000 (SPRITE 0), $D002 (SPRITE 1)
 AND SO ON, AND THE Y COORDINATE REGISTERS ARE $D001, $D003 ETC. S THESE
 REGISTERS CAN ONLY STORE ONE BYTE EACH, YOU CAN ONLY SET COORDINATES
 BETWEEN 0 AND 255. UT THE VISIBLE PORTION OF THE SCREEN IS 320 PIXELS
 WIDE! HE SOLUTION IS THAT THERE'S AN 8TH BIT FOR EACH X REGISTER IN
 $D010. O, IF BIT 0 IN $D010 IS SET, SPRITE 0'S X COORDINATE IS 256, PLUS
 THE VALUE IN $D000. HIS MIGHT SOUND A BIT COMPLICATED, BUT YOU'LL GET
 USED TO IT PRETTY QUICKLY.

 ETTING THE COLOURS IS THE EASIEST PART. OR SINGLE COLOUR SPRITES, YOU
 JUST POKE THE COLOUR VALUE OF EACH SPRITE INTO THE ADDRESSES $D027, $D028
 ETC. EAD YOUR FAVOURITE  REFERENCE FOR INFORMATION ON OTHER STUFF THAT
 YOU CAN DO WITH SPRITES...

 PRITE XAMPLE

 ERE'S AN EXAMPLE THAT MOVES A SPRITE AROUND ON THE SCREEN:

      * = $0801

      LDA #$01
      STA $D015    ; URN SPRITE 0 ON
      STA $D027    ; AKE IT WHITE
      LDA #$40
      STA $D000    ; SET X COORDINATE TO 40
      STA $D001    ; SET Y COORDINATE TO 40
      LDA #$80
      STA $07F8    ; SET POINTER: SPRITE DATA AT $2000

 MAINLOOP
      LDA $D012
      CMP #$FF     ; RASTER BEAM AT LINE $FF?
      BNE MAINLOOP ; NO: GO TO MAINLOOP

      LDA DIR      ; IN WHICH DIRECTION ARE WE MOVING?
      BEQ DOWN     ; IF 0, DOWN

            ; MOVING UP
      LDX COORD    ; GET COORD
      DEX          ; DECREMENT IT
      STX COORD    ; STORE IT
      STX $D000    ; SET SPRITE COORDS
      STX $D001
      CPX #$40     ; IF IT'S NOT EQUAL TO $40...
      BNE MAINLOOP ; JUST GO BACK TO THE MAINLOOP

      LDA #$00     ; OTHERWISE, CHANGE DIRECTION
      STA DIR
      JMP MAINLOOP

 DOWN
      LDX COORD    ; THIS SHOULD BE FAMILIAR
      INX
      STX COORD
      STX $D000
      STX $D001
      CPX #$E0
      BNE MAINLOOP

      LDA #$01
      STA DIR
      JMP MAINLOOP

 COORD
      .BYTE $40   ; CURRENT X AND Y COORDINATE
 DIR
      .BYTE 0     ; DIRECTION: 0 = DOWN-RIGHT, 1 = UP-LEFT

 HAT'S A BIT MORE CODE THAN IN THE PREVIOUS EXAMPLES, BUT IT SHOULDN'T BE
 HARD TO UNDERSTAND. UST READ THE CODE AND COMMENTS AND YOU SHOULD BE ABLE
 TO UNDERSTAND IT.

 F YOU TYPE IN AND RUN THE EXAMPLE PROGRAM (YOU SHOULD), YOU'LL NOTICE
 THAT THE MOVEMENT ISN'T VERY SMOOTH. T'S NOT LIKE ANYONE WOULD ACCEPT A
 JERKY MOVEMENT LIKE THAT IN A REAL DEMO, SO YOU'LL HAVE TO FIX IT. HE
 QUESTION TO ASK IS WHY IT'S MOVING SO JERKY. HE THING IS THAT WE HAVEN'T
 TURNED OFF TIMER INTERRUPTS. HIS MEANS THAT SOMETIMES WE'LL BE IN THE
 KERNAL INTERRUPT HANDLER WHILE WE'RE PASSING RASTER LINE $FF, WHICH MEANS
 WE'LL MISS IT, AND THE SPRITE MOVEMENT WON'T BE UPDATED UNTIL THE NEXT
 FRAME. OU'LL LEARN MORE ABOUT INTERRUPTS LATER.

  GOOD EXERCISE, TO GET YOUR HANDS DIRTY WITH SOME MORE INTERESTING SPRITE
 PROGRAMMING, WOULD BE TO DISPLAY SEVERAL SPRITES AT ONCE, AND MAKE THEM
 MOVE ACCORDING TO A SINE TABLE. ITH THE HELP OF YOUR FRIEND $D012, YOU
 SHOULD ALSO BE ABLE TO MAKE A MULTIPLEXER, IF YOU'RE REALLY AMBITIOUS.
 OU'VE GOT ALL THE TOOLS, NOW ALL YOU HAVE TO DO IS TO THINK IT UP AND
 EXPRESS IT IN CODE.

HARACTER RAPHICS

 PRITES ISN'T THE ONLY WAY TO DISPLAY GRAPHICS. UR NEXT TOPIC IS
 CHARACTER GRAPHICS. OU MIGHT HAVE TRIED TO DRAW SOMETHING USING THE
 BUILT-IN CHARACTER SET. HAT'S NOT VERY EASY, AND THE RESULTS USUALLY
 AREN'T ALL THAT GOOD. F COURSE, YOU DON'T HAVE TO USE THE BUILT-IN
 CHARACTER SET. SING A CHARACTER SET EDITOR, YOU CAN DRAW YOUR OWN
 CHARACTER SET, AND MORE EFFECTS THAN YOU CAN IMAGINE ARE IMPLEMENTED USING
 CHARACTER GRAPHICS. HEY DON'T EVEN HAVE TO LOOK LIKE CHARACTERS, IF THE
 TRICK IS (AS IT OFTEN IS) TO UPDATE THE CHARACTER SET IN REALTIME.

 EFORE WE GET INTO THOSE KINDS OF TRICKS, WE'LL DO WHAT WE USUALLY DO AND
 GO THROUGH THE BASICS FIRST.

 CREEN AND OLOUR 

 S YOU SHOULD ALREADY KNOW (FROM READING THE SECTION ON LEARNING ), YOU
 CHANGE CHARACTERS ON THE SCREEN BY PUTTING THE CHARACTER VALUES INTO
 SCREEN MEMORY. CREEN MEMORY IS $03E8 BYTES LONG AND IS LOCATED AT $0400,
 UNLESS YOU MOVE IT SOMEWHERE ELSE. HE SCREEN CODES AREN'T THE SAME AS THE
  CODES YOU USE FOR NORMAL TEXT, SO IF YOU WANT TO PREPARE TEXT THAT
 SHOULD BE PUT ON THE SCREEN, MAKE SURE YOU SAVE IT AS SCREEN CODES. OST
 DEMO RELATED TEXT EDITORS AND SUCH ALREADY DO THAT, SO THERE'S NOTHING TO
 WORRY ABOUT.

 OW, PUTTING CHARACTERS ON THE SCREEN IS COOL, BUT IT GETS EVEN COOLER IF
 YOU CAN GIVE EACH CHARACTER ITS OWN COLOUR. OU CAN DO THIS BY POKING THE
 COLOUR VALUES INTO COLOUR , WHICH IS ALWAYS LOCATED AT $D800 (YOU CAN'T
 MOVE IT).

 O, LET'S SAY YOU WANT THE LETTER  TO APPEAR IN THE UPPER LEFT CORNER OF
 THE SCREEN, AND YOU WANT IT TO BE YELLOW. HAT DO YOU DO? OU POKE THE
 SCREEN CODE FOR  INTO SCREEN MEMORY, IE. PUT THE VALUE 1 INTO MEMORY
 POSITION $0400, AND PUT THE VALUE FOR YELLOW, WHICH IS 7, IN $D800.

 HANGING HARACTER ET

 HE BUILT-IN CHARACTER SET ISN'T SO HOT, SO IF YOU'RE GOING TO DISPLAY
 TEXT, YOU SHOULD USUALLY LOAD YOUR OWN CHARACTER SET. ORTUNATELY, THIS IS
 VERY EASY, AND YOU CAN CONTROL THE LOCATIONS OF BOTH THE CHARACTER SET AND
 THE SCREEN MEMORY WITH ONE  REGISTER: $D018. OU PUT THE UPPER PARTS OF
 TWO ADDRESSES INTO THIS REGISTER: THE FOUR MOST SIGNIFICANT BITS OF THE 14
 BIT9 ADDRESS OF THE SCREEN MEMORY IN THE FOUR HIGH BITS, AND THE FOUR MOST
 SIGNIFICANT BITS OF THE 14 BIT ADDRESS OF THE CHARACTER SET IN THE LOWER
 FOUR BITS. ONFUSED? ET'S TAKE AN EXAMPLE...

 CREEN MEMORY IS $0400 BYTES LONG, AND IT HAS TO START ON AN ADDRESS THAT
 IS A MULTIPLE OF $0400, SO IT CAN START AT $0000, $0400, $0800, $0C00 ETC.
 S  SAID, IT'S LOCATED AT $0400 BY DEFAULT.  CHARACTER SET IS $0800
 BYTES LONG, AND HAS TO START ON AN ADDRESS THAT IS A MULTIPLE OF $0800, SO
 IT CAN BE LOCATED AT $0000, $0800, $1000, $1800 ETC. OW, LET'S SAY WE
 WANT SCREEN MEMORY TO BE WHERE IT USUALLY IS, AT $0400, AND WE HAVE A
 CHARACTER SET AT $2000. E WANT THE FOUR MOST SIGNIFICANT BITS OF THE 14
 BIT ADDRESS $0400, WHICH IS 1 (IN BINARY, $0400 IS 0000 0100 0000 0000,
 AND IF YOU COUNT 14 BITS FROM THE RIGHT, YOU GET 00 0100 0000 0000, OF
 WHICH 0001 ARE THE FOUR MOST SIGNIFICANT BITS). E ALSO WANT THE FOUR MOST
 SIGNIFICANT BITS OF THE 14 BIT ADDRESS $2000 (THE CHARACTER SET). N
 BINARY, $2000 IS 0010 0000 0000 0000, WHICH MEANS THE FOUR MOST
 SIGNIFICANT BITS OF THE 14 BIT ADDRESS IS 1000, WHICH IS 8.

 O, WHAT DO WE ACTUALLY STORE IN $D018? E WANT 1 IN THE FOUR MOST
 SIGNIFICANT BITS AND 8 IN THE FOUR LEAST SIGNIFICANT BITS, IE. $18.

 OW,  MAY HAVE MADE THIS A BIT TOO COMPLICATED. T'S REALLY NOT THAT
 DIFFICULT. ERE'S A TRICK: TO FIND OUT WHICH VALUE TO STORE IN $D018, JUST
 COUNT THE NUMBER OF $0400 CHUNKS UNTIL THE START OF THE ADDRESS YOU'RE
 INTERESTED IN. F YOUR SCREEN MEMORY SHOULD START AT $1800, YOU COUNT
 $0000, $0400, $0800, $0C00, $1000, $1400. HAT'S 6, SO YOU USE 6 IN THE
 UPPER FOUR BITS OF $D018. SE THE SAME VALUES FOR THE CHARACTER SET, BUT
 PUT IT IN THE LOWER FOUR BITS OF $D018.

 LTERING THE HARACTER ET IN EALTIME

  MENTION ABOVE THAT YOU CAN MAKE INTERESTING EFFECTS BY ALTERING THE
 CHARACTER SET IN REALTIME. OW DO YOU DO THIS? ELL, IF YOU'VE SPECIFIED
 THAT YOU WANT YOUR CHARACTER SET AT $2000, YOU CAN START POKING VALUES IN
 THE ADDRESSES FROM $2000 TO $2800, AND SEE WHAT HAPPENS. S YOU'RE
 ALTERING THE CHARACTER SET THAT'S USED FOR DISPLAYING WHAT'S ON THE
 SCREEN, THE THINGS ON THE SCREEN WILL CHANGE IMMEDIATELY. OU DON'T HAVE
 TO CHANGE ANYTHING IN SCREEN MEMORY, JUST IN THE CHARACTER SET.

  CLASSICAL EXAMPLE OF AN EFFECT THAT YOU CAN DO BY POKING DATA INTO A
 CHARACTER SET IS A  (IFFERENT  HARACTER OSITIONS).   IS A
 SCROLL TEXT WHERE THE LETTERS MOVE UP AND DOWN, INDEPENDENT OF EACH OTHER.
 OU CAN FIGURE OUT HOW TO DO IT YOURSELF, OR READ THE ARTICLE ABOUT IT IN
 OMMODORE ACKING.

 N EASIER EXERCISE THAN WRITING A  WOULD BE TO CREATE SOME ANIMATED
 GRAPHICS BY CHANGING THE CHARACTER DATA. OU CAN ALSO USE THIS TO SCROLL
 TEXT WITHOUT USING $D016, BY ING THE CHAR DATA THROUGH CHARACTER
 MEMORY...

 ERE'S A SIMPLE EXAMPLE PROGRAM, THAT DOESN'T REALLY DO MUCH, EXCEPT
 ILLUSTRATE WHAT 'VE JUST WRITTEN. T SETS THE POSITION OF THE CHARACTER
 SET TO $2000, AND THEN ALTERS IT IN REALTIME. OTE THAT 'M USING $D012,
 AS ALWAYS.

      * = $0801

      LDA #$00     ; BLACK
      STA $D020    ; BORDER BACKGROUND COLOUR
      STA $D021    ; SCREEN BACKGROUND COLOUR

      TAX          ; SET  TO 0 TOO

 CLRSCREEN               ; SET ALL CHAR CODES TO 0
      STA $0400,X  ; ON THE SCREEN
      STA $0500,X
      STA $0600,X
      STA $0700,X
      STA $2000,X  ; AND SET CHARSET DATA TO 0
      DEX
      BNE CLRSCREEN

      LDA #$18     ; SCREEN AT $0400, CHARS AT $2000
      STA $D018

 MAINLOOP
      LDA $D012   
      CMP #$FF     ; ON RASTER LINE $FF?
      BNE MAINLOOP ; NO, GO TO MAINLOOP

      LDX COUNTER  ; GET OFFSET VALUE
      INX          ; INCREMENT IT
      CPX #$28     ; IF IT'S $28, START OVER
      BNE JUSTSTX
      LDX #$00
 JUSTSTX
      STX COUNTER

      LDA $2000,X  ; GET BYTE NR X FROM CHARDATA
      EOR #$FF     ; INVERT IT
      STA $2000,X  ; STORE IT BACK

      JMP MAINLOOP ; KEEP GOING...

 COUNTER
      .BYTE 8      ; INITIAL VALUE FOR COUNTER

 OME SMALL THINGS IN THE EXAMPLE MIGHT HAVE TO BE EXPLAINED. HE REASON
 WHY 'M COUNTING TO $28, AND NOT JUST 8 (WHICH WOULD BE SUFFICIENT FOR
 INVERTING EVERY BYTE THAT MAKE UP THE CHARACTER 0), IS SO THAT IT WON'T BE
 TOO FAST TO SEE WHAT'S GOING ON. HE REASON WHY WE'RE POKING STUFF INTO
 $2000 AND UP IS THAT WE'RE USING CHARACTER NUMBER 0. HE DATA FOR CHAR 0
 STARTS AT $2000, THE DATA FOR CHAR 1 STARTS AT $2008, THE DATA FOR CHAR 2
 AT $2010 AND SO ON.

 KAY, THAT'S ALL 'M GOING TO SAY ABOUT CHARACTER GRAPHICS RIGHT NOW. OU
 KNOW THE BASICS, NOW ALL YOU HAVE TO DO IS TO EXPERIMENT AND THINK UP COOL
 THINGS TO DO WITH CHARACTER GRAPHICS.

 OTE THAT  HAVEN'T MENTIONED MULTICOLOUR CHARACTER GRAPHICS. SING
 MULTICOLOUR, YOU CAN GET YOUR CHARACTERS TO HAVE 3 COLOURS EACH, ONE OF
 WHICH IS SET IN COLOUR , AND TWO WHICH ARE SET IN $D022 AND $D023. HE
 COLOURS IN COLOUR  ARE OF COURSE DIFFERENT FOR EVERY CHARACTER, BUT
 $D022 AND $D023 CAN'T BE CHANGED FOR EACH CHARACTER.

ITMAP RAPHICS

 HARACTER SETS ARE GOOD FOR A LOT OF THINGS, BUT IF YOU WANT A PICTURE
 THAT COVERS THE WHOLE SCREEN, A CHARACTER SET WON'T DO, BECAUSE YOU CAN'T
 SET EVERY PIXEL ON THE SCREEN, USING ONLY $0800 BYTES. HERE ARE 320 X 200
 PIXELS ON THE SCREEN IN HIRES MODE, AND 160 X 200 IN COLOUR MODE, SO YOU
 NEED ABOUT $2000 BYTES TO HAVE TOTAL CONTROL OF THE GRAPHICS ON THE
 SCREEN.

 OWEVER, IF THE PICTURE YOU WANT TO DISPLAY IS ''SIMPLE'' ENOUGH, IE. IF
 LARGE PARTS OF IT ARE EMPTY, OR IF IT'S HIGHLY REPETITIVE, SO THAT IT
 COULD BE DRAWN WITH A SINGLE CUSTOMIZED CHARACTER SET, YOU CAN OF COURSE
 JUST USE A CHARSET TO DISPLAY IT, AND YOU'LL SAVE YOURSELF $1800 BYTES OF
 MEMORY. HERE ARE TOOLS TO CONVERT A BITMAP TO A CHARACTER SET + A SCREEN
 MEMORY, WHICH OF COURSE REQUIRES THAT THE INFORMATION CONTAINED IN THE
 BITMAP WILL FIT INTO A CHARSET.

 F YOU'VE UNDERSTOOD HOW CHARACTER GRAPHICS WORK, YOU SHOULDN'T HAVE ANY
 PROBLEMS UNDERSTANDING HOW TO DISPLAY BITMAP GRAPHICS. 'LL DESCRIBE HOW
 YOU CAN DISPLAY HIRES GRAPHICS AND MULTICOLOUR GRAPHICS IN THE OALA AINT
 FORMAT.

 HE ONCEPTS OF ITMAP RAPHICS

 HEN YOU DISPLAY CHARACTER GRAPHICS, YOU HAVE TO SET $D018 TO POINT TO
 SCREEN  AND CHARACTER SET. F YOU WANT TO DISPLAY A BITMAP PICTURE, YOU
 HAVE TO DO ALMOST THE SAME THING. OU HAVE TO SET THE LOCATION OF SCREEN
  (WHICH IS USED FOR TWO SETS OF COLOURS FOR EACH CHARACTER (YES, IN A
 WAY YOU'RE STILL USING CHARACTER)) AND OF THE BITMAP. HE BITMAP TAKES UP
 ALMOST $2000 BYTES, AND IT HAS TO BE PROPERLY ALIGNED, SO YOU CAN'T PUT A
 BITMAP AT EG. $2800, IT HAS TO BE AT $2000, $4000, $6000 ETC.

 EFORE WE GO INTO THE THEORY OF HOW YOU DISPLAY A BITMAP, 'LL GIVE YOU AN
 EXAMPLE, AND THEN 'LL EXPLAIN WHAT IT DOES. HE EXAMPLE REQUIRES THAT YOU
 HAVE A OALA PICTURE LOADED AT $2000. OALA PICTURES ARE USUALLY LOADED TO
 $6000, SO GO INTO YOUR MONITOR AND TYPE L ''FILENAME'',08,2000. HAT WILL
 LOAD YOUR PICTURE TO $2000.

      * = $0801

      LDA #$00
      STA $D020  
      STA $D021    ; SET BORDER AND SCREEN COLOUR TO BLACK

      TAX
 COPYLOOP:
      LDA $3F40,X  ; COPY COLOURS TO SCREEN 
      STA $0400,X
      LDA $4040,X
      STA $0500,X
      LDA $4140,X
      STA $0600,X
      LDA $4240,X
      STA $0700,X
      LDA $4328,X  ; COPY COLOURS TO COLOUR 
      STA $D800,X
      LDA $4428,X
      STA $D800,X
      LDA $4528,X
      STA $D800,X
      LDA $4628,X
      STA $D800,X
      DEX
      BNE COPYLOOP

      LDA #$3B     ; BITMAP MODE
      LDX #$18     ; MULTI-COLOUR MODE
      LDY #$18     ; SCREEN AT $0400, BITMAP AT $2000
      STA $D011
      STX $D016
      STY $D018

 MAINLOOP:
      JMP MAINLOOP ; KEEP GOING...

 S  STILL HAVEN'T EXPLAINED EVERYTHING ABOUT BITMAP MODE, THIS MIGHT NOT
 BE ALL THAT CLEAR, BUT IT'S STILL A VERY SMALL EXAMPLE PROGRAM AND IT'LL
 DISPLAY A OALA PICTURE JUST FINE.

 E START BY MAKING THE BORDER AND BACKGROUND BLACK. HIS ISN'T ACTUALLY
 ACCURATE, AS THE BACKGROUND COLOUR IS STORED IN THE OALA FORMAT, SO WE
 REALLY SHOULD HAVE LOADED THE VALUE FROM $4711 AN PUT IT IN $D021, BUT
 THAT'S NOT REALLY IMPORTANT.

 EXT WE START COPYING STUFF. HY DO WE DO THAT. ELL, WE'LL KEEP USING
 $0400 AS SCREEN , SO WE'LL HAVE TO COPY THE SCREEN , WHICH, IN THE
 OALA FORMAT, IS LOCATED AT $3F40, TO $0400. HAT'S EASY, YOU'VE SEEN THAT
 ONE BEFORE. HE SAME GOES FOR COLOUR , WHICH STARTS AT $4328, WHICH
 WILL HAVE TO BE COPIED TO $D800.

 HEN WE HAVE ALL THE DATA IN THE RIGHT PLACES, ALL WE NEED TO DO IS TO
 TELL THE  CHIP WHAT MODE TO GO INTO, AND WHERE IT SHOULD READ DATA. E
 TELL IT TO GO INTO BITMAP MODE BY SETTING $D011 TO $3B, AND BY SETTING
 $D016 TO $18 WE TURN ON MULTI-COLOUR MODE. ND THEN WE TELL IT TO READ
 SCREEN  AT $0400 AND THE BITMAP AT $2000, BY SETTING $D018 TO $18.

 HE LAST LINE JUST LOOPS FOREVER, SO THAT YOU GET A CHANCE TO WATCH THE
 PICTURE. OPEFULLY YOU'VE FOUND A NICE ONE. :-)

 F YOU DON'T KNOW WHERE TO FIND A OALA PICTURE, GET A PROGRAM LIKE MICA
 AINT, OALA AINT OR OLOR-16, AND DRAW YOUR OWN PICTURES. OU CAN OF
 COURSE ALSO RIP PICTURES FROM OTHER PEOPLE'S PRODUCTIONS, BUT PLEASE,
 DON'T USE RIPPED GRAPHICS IN YOUR DEMOS, THAT'S LAME.

 HE CREEN AYOUT

 HE LAYOUT OF THE ACTUAL BITMAP IS A BIT WEIRD, ESPECIALLY IF YOU'RE USED
 TO OTHER ARCHITECTURES, WHICH HAVE NICE, LINEAR BITMAPS 10.  -64 BITMAP
 ISN'T LINEARLY ADRESSABLE, IE. YOU CAN'T JUST COUNT THE PIXELS FROM LEFT
 TO RIGHT AND INDEX INTO IT IN AN EASY WAY.

 HE DATA IN A -64 BITMAP ARE INDEXED VERY MUCH LIKE A NORMAL CHARSET. HE
 FIRST BYTE (IN THE ABOVE EXAMPLE $2000) IS THE TOP, LEFTMOST BYTE. $2001
 IS THE BYTE BELOW THAT ONE, $2002 BELOW THAT ONE, AND SO ON, UNTIL $2008,
 WHICH IS THE ONE TO THE RIGHT OF $2000. O, BASICALLY, IT'S AS IF YOU'D
 READ ONE CHARACTER FROM A CHARSET, AND PUT THAT CHARACTER IN THE TOP LEFT
 CORNER OF THE SCREEN, AND THEN YOU READ THE NEXT CHARACTER AND PUT NEXT TO
 THAT ONE, AND SO ON, UNTIL YOU REACH CHARACTER 40, WHICH IS BELOW
 CHARACTER 0.

 T'S NOT REALLY HARD TO UNDERSTAND, BUT IT DOES MAKE IT A BIT DIFFICULT TO
 IMPLEMENT EFFICIENT BITMAP EFFECTS, LIKE PLOTTERS. HINK ABOUT IT!

 ISPLAYING ITMAPS

 ISPLAYING A SINGLE-COLOUR BITMAP IS JUST LIKE DISPLAYING A MULTI-COLOUR
 BITMAP, EXCEPT THAT YOU DON'T USE COLOUR-. HY? ECAUSE ALL YOU NEED IS
 A BACKGROUND COLOUR AND A FOREGROUND COLOUR, AND YOU CAN USE THE GOOD OLD
 SCREEN  FOR THAT. OR EACH BYTE IN THE SCREEN , YOU SET THE UPPER
 NYBBLE TO ONE COLOUR VALUE, AND THE LOWER NYBBLE TO ANOTHER VALUE (OR THE
 SAME VALUE, BUT THEN YOU WON'T SEE ANYTHING OF THE BITMAP).

 HE LAST PARAGRAPH MIGHT SOUND A BIT CRYPTIC, BUT JUST TRY IT OUT. ET
 YOURSELF A NICE HIRES BITMAP (USE SOME UTILITY TO CREATE ONE, IT SHOULD
 OUTPUT A FILE THAT IS 33 BLOCKS LONG). OAD THAT BITMAP TO SOME $2000
 ALIGNED ADDRESS (LIKE $2000), SET $D011 TO $3B, $D016 TO $08 (SINGLE
 COLOUR MODE) AND $D018 TO $18. HEN YOU CAN START POKING VALUES INTO $0400
 ETC., TO SEE WHAT HAPPENS.

 OES THAT SOUND TOO SIMPLE? T IS SIMPLE.

               NTERRUPTS

 KAY, SO FAR WE'VE LEARNT A LOT OF USEFUL THINGS FOR PUTTING GRAPHICS ON
 THE SCREEN (AND PLAYING MUSIC, BUT THAT'S ALMOST TOO EASY TO MENTION). O
 SUM IT ALL UP, WE HAVE ALL THE TOOLS WE NEED TO WRITE PROGRAMS THAT
 DISPLAY GRAPHICS AND PLAY MUSIC. ULTIMEDIA PROGRAMS, OR SOMETHING LIKE
 THAT. E DON'T KNOW EVERYTHING WE NEED TO WRITE DEMOS, THOUGH. EMOS, AS 
 SAID IN THE INTRODUCTION, ARE QUITE DIFFERENT FROM PROGRAMS THAT DISPLAY
 GRAPHICS AND PLAY MUSIC.

 LL THE EXAMPLE PROGRAMS ABOVE HAVE SUFFERED FROM ONE GREAT PROBLEM: THEY
 HAVE BEEN BADLY TIMED, AND ALL MOVEMENT (AS WELL AS THE PLAYBACK OF THE
 MUSIC) HAS BEEN JERKY AND INEXACT. E NEED TO DO SOMETHING ABOUT THAT. OU
 CAN'T HAVE A SCROLL TEXT THAT DOESN'T MOVE SMOOTHLY, OR JITTERING RASTER
 BARS, BECAUSE THAT'S THE DEFINITION OF LAMENESS.

 O, HOW DO WE DO SOMETHING ABOUT IT? ELL, WE NEED TO KNOW A BIT ABOUT
 INTERRUPTS. F COURSE, AS A DEMO CODER, YOU REALLY NEED TO KNOW EVERYTHING
 ABOUT INTERRUPTS, BUT WE'RE NOT GOING TO BE THAT COMPLETE HERE. E'RE
 GOING TO BE COMPLETE ENOUGH SO THAT YOU CAN EASILY LEARN THE REST BY
 READING YOUR REFERENCE MATERIAL AND POKING AROUND IN YOUR COMPUTER
 YOURSELF, THOUGH. IZARDRY ISN'T ABOUT KNOWING MOST OF WHAT THERE IS TO
 KNOW, IT'S ABOUT BEING ABLE TO SETUP INTERRUPT HANDLERS AFTER 20 BEERS
 (TRUST ME, THAT'S NOT EASY :-).

HY NTERRUPTS

  SUPPOSE WE'LL HAVE TO ANSWER THIS QUESTION, ALTHOUGH IT MIGHT SEEM
 STUPID. HERE REALLY ISN'T ANYTHING THAT KEEPS YOU FROM WRITING DEMOS THAT
 DON'T USE INTERRUPTS. F YOU JUST KNOW HOW TO TURN OF THE  INTERRUPTS,
 YOU'RE SAFE FROM ALL THE JITTERING AND FLICKERING WE'VE EXPERIENCED SO
 FAR. UT THERE ARE MORE THINGS YOU CAN DO WITH THE HELP OF INTERRUPTS, AND
 YOU REALLY NEED TO KNOW ABOUT THEM IN ORDER TO HAVE CONTROL OVER YOUR
 COMPUTER. ND DEMOS ARE ALL ABOUT CONTROL. OU'LL ALSO NEED TO KNOW ABOUT
 INTERRUPTS TO BE ABLE TO USE AN -LOADER, AND IF YOU'RE PLANNING TO EVER
 WRITE A DEMO THAT'S BIGGER THAN WHAT WILL FIT IN YOUR COMPUTER'S MEMORY,
 YOU'LL NEED TO USE A LOADER. ND THERE'S NO EXCUSE FOR NOT USING AN
 -LOADER THESE DAYS.

 N THIS TEXT, WE'LL CONCENTRATE ON RASTER INTERRUPTS, BECAUSE THAT'S WHAT
 YOU'LL USE MOST OFTEN IN DEMOS. E'LL ALSO GO INTO S A BIT, BECAUSE
 IT'S VERY USEFUL TO KNOW ABOUT THEM. ND OF COURSE, IF YOU'VE WRITTEN A
 DEMO THAT LOOKS GREAT AND THAT PEOPLE LOVE, IT CAN FEEL PRETTY EMBARRASING
 IF YOU CAN KILL IT JUST BY PRESSING / + ...

HAT IS AN NTERRUPT?

  FAIR QUESTION TO ASK AT THIS STAGE IS WHAT AN INTERRUPT IS. HEY'RE A
 VERY SIMPLE, AND VERY EFFICIENT WAY OF HANDLING SOME THINGS. HEY WORK
 PRETTY MUCH LIKE AN ALARM CLOCK.

 ET'S SAY YOU'RE GOING TO BED AFTER A LONG NIGHT OF DEMO CODING, AND YOU
 HAVE TO GET UP AT EIGHT IN THE MORNING, TO GO TO SCHOOL OR WORK. HAT DO
 YOU DO? OU SET YOUR ALARM CLOCK TO RING AT EIGHT, AND THEN YOU CAN SAFELY
 GO TO SLEEP, WITHOUT HAVING TO WORRY, KNOWING THAT THE CLOCK WILL WAKE YOU
 UP AT EIGHT. NTIL THEN, YOU CAN SLEEP ALL YOU WANT.

 HAT'S EXACTLY HOW INTERRUPTS WORK: YOU SET UP AN INTERRUPT TO WAKE UP THE
  AT SOME TIME AND TELL IT TO DO SOMETHING SPECIAL, BUT UNTIL THEN THE
  CAN DO ITS NORMAL THINGS. O, WHAT YOU DO WHEN YOU SET UP AN INTERRUPT
 IS TO DEFINE WHEN THE INTERRUPT SHOULD HAPPEN AND WHAT SHOULD HAPPEN WHEN
 THE INTERRUPT IS TRIGGERED.

 N THE -64, YOU HAVE SOME DIFFERENT TYPES OF INTERRUPTS TO WATCH OUT FOR.
 OU HAVE TWO S, WHICH CAN BOTH GENERATE TIMER INTERRUPTS (TELL THE 
 TO GIVE YOU AN INTERRUPT AFTER  CLOCK CYCLES), YOU HAVE THE , WHICH
 CAN GENERATE RASTER INTERRUPTS (GENERATE AN INTERRUPT WHEN WE REACH A
 CERTAIN RASTER LINE), SPRITE COLLISION INTERRUPTS (GENERATE AN INTERRUPT
 WHEN TWO SPRITES COLLIDE) ETC.

OW TO MPLEMENT NTERRUPTS

 EAH, SO HOW DO YOU SET UP A RASTER INTERRUPT? T'S ACTUALLY VERY EASY, SO
 'LL JUST GIVE YOU SOME EXAMPLE CODE, AND THEN EXPLAIN IT.

      * = $1000

      SEI          ; TURN OFF INTERRUPTS
      LDA #$7F
      LDX #$01
      STA $DC0D    ; URN OFF  1 INTERRUPTS
      STA $DD0D    ; URN OFF  2 INTERRUPTS
      STX $D01A    ; URN ON RASTER INTERRUPTS

      LDA #$1B
      LDX #$08
      LDY #$14
      STA $D011    ; LEAR HIGH BIT OF $D012, SET TEXT MODE
      STX $D016    ; SINGLE-COLOUR
      STY $D018    ; SCREEN AT $0400, CHARSET AT $2000

      LDA #<INT    ; LOW PART OF ADDRESS OF INTERRUPT HANDLER CODE
      LDX #>INT    ; HIGH PART OF ADDRESS OF INTERRUPT HANDLER CODE
      LDY #$80     ; LINE TO TRIGGER INTERRUPT
      STA $0314    ; STORE IN INTERRUPT VECTOR
      STX $0315
      STY $D012

      LDA $DC0D    ;   1 INTERRUPTS
      LDA $DD0D    ;   2 INTERRUPTS
      ASL $D019    ;   INTERRUPTS
      CLI

 LOOP:
      JMP LOOP     ; INFINITE LOOP

 INT:
      INC $D020    ; FLASH BORDER

      ASL $D019    ;  INTERRUPT (TO RE-ENABLE IT)
      PLA
      TAY
      PLA
      TAX
      PLA
      RTI          ; RETURN FROM INTERRUPT

 OW, IF YOU'RE NOT USED TO USING INTERRUPTS, THAT MIGHT LOOK A BIT WEIRD.
 T WORKS, THOUGH, AND 'M NOW GOING TO TELL YOU HOW. (ELL, 'LL TRY,
 ANYWAY. :-)

 E START BY TURNING OFF ALL INTERRUPTS, WITH AN  INSTRUCTION. HE
 REASON WHY WE DO THIS IS BECAUSE IF WE GET AN INTERRUPT IN THE MIDDLE OF
 SETTING UP INTERRUPTS, THINGS CAN GET MESSED UP AND THE PROGRAM CAN CRASH.
 HESE THINGS HAPPEN. VER HAD A DEMO CRASH UNPREDICTABLY? OMETIMES IT
 WORKS, SOMETIMES IT DOESN'T? HE INTERRUPT SETUP MIGHT BE SCREWED UP. R
 THERE CAN BE SOME OTHER REASON. EAD THE CODE AND SEE IF YOU CAN FIND IT.
 :-)

 O, ANYWAY, AFTER THE , THE ACTION BEGINS. E START BY TURNING OFF ALL
  INTERRUPTS. E DO THIS BY POKING $7F INTO $DC0D AND $DD0D. O FIND OUT
 WHAT THE VALUE $7F MEANS, READ SOME REFERENCE. T A LATER STAGE, YOU MIGHT
 BE INTERESTED IN FINDING OUT WHAT THE INDIVIDUAL BITS OF THOSE REGISTERS
 DO. E THEN TURN ON RASTER INTERRUPTS, BY SETTING THE LOWEST BIT OF $D01A.

 HE NEXT THING WE DO IS TO SETUP $D011, $D016 AND $D018. OU SHOULD
 RECOGNIZE THOSE BY NOW. E ALWAYS HAVE TO INITIALIZE THEM, AND  USUALLY
 DO IT AT THE SAME TIME AS THE INTERRUPT SETUP. HE ONLY BIT THAT'S
 RELEVANT IN THIS CONTEXT (INTERRUPTS) IS BIT 7 OF $D011, WHICH IS THE 8TH
 BIT OF $D012 (AS WE HAVE MORE THAN 256 RASTER LINES, BUT 'VE ALREADY
 TALKED ABOUT THAT ABOVE).

 O, LET'S MOVE ON TO THE NEXT CHUNK OF INSTRUCTIONS, WHICH INCLUDES $D012.
 E SET A NEW ADDRESS IN THE INTERRUPT VECTOR, $0314. HIS ADDRESS SIMPLY
 SPECIFIES WHERE THE PROCESSOR SHOULD KEEP EXECUTING CODE WHEN AN INTERRUPT
 OCCURS. E POINT IT TO OUR INTERRUPT ROUTINE, INT.

 N THE INTERRUPT HANDLER CODE, WE DON'T DO MUCH. IRST WE FLASH THE
 BORDER, BY -INC $D020 (AND OF COURSE, THIS HAPPENS ONCE EVERY FRAME),
 THEN WE  THE INTERRUPT (SET BIT 0 OF $D019, WHICH  USUALLY DO WITH 
 $D019, FOR SOME REASON (PROBABLY BECAUSE THAT'S HOW IT WAS DONE IN THE
 EXAMPLE THAT  LEARNT ABOUT INTERRUPTS FROM). F WE FORGET TO DO THIS, THE
 INTERRUPT WILL BE TRIGGERED AGAIN, RIGHT AFTER WE RETURN FROM THIS
 INTERRUPT CODE. O WE HAVE TO TELL THE  THAT WE'VE HANDLED THIS
 INTERRUPT, SO THAT IT IS CLEARED.

 HEN WE HAVE TO RESTORE THE REGISTER CONTENTS FROM THE STACK (THESE ARE
 STORED THERE WHEN THE INTERRUPT OCCURS), AND THEN EXECUTE THE INSTRUCTION
 , WHICH RETURNS FROM THE INTERRUPT. UITE OFTEN YOU WON'T SEE EXACTLY
 THIS CODE, BUT INSTEAD OF THE LAST SIX LINES YOU'LL SEE A  TO $EA31 OR
 $EA81. $EA31 IS THE DEFAULT INTERRUPT HANDLER, WHICH DOES THIS AND THAT
 THAT YOU'LL WANT IF YOU'RE IN , BUT YOU WON'T NEED THAT CRAP WHEN
 YOU'RE CODING DEMOS, SO SKIP IT. $EA81 JUST CONTAINS THE SAME CODE AS THE
 LAST SIX LINES IN OUR PROGRAM, SO EXACTLY THE SAME THING HAPPENS, EXCEPT
 THAT WE WASTE THREE CLOCK CYCLES (FOR THE ) AND THAT WE SAVE 3 BYTES OF
 MEMORY. O IT'S A TRADE-OFF, KIND OF, BUT IT'S NOT OFTEN 3 CLOCK-CYCLES OR
 3 BYTES WILL BOTHER YOU VERY MUCH, SO WHO CARES?

 F COURSE YOU CAN'T JUMP TO  ROUTINES IF YOU'VE SWITCHED OUT KERNAL
 , SO IT'S A GOOD IDEA TO USE THE CODE ABOVE ANYWAY.

 HERE'S A MODIFICATION YOU CAN DO TO THE CODE ABOVE, WHICH MIGHT BE NICE
 TO TRY, AND GIVE YOU SOME FURTHER INSIGHT INTO HOW INTERRUPTS WORK.
 NSTEAD OF ING AROUND IN THE INFINITE LOOP ( LOOP), DO . ND ADD
  $EA31 INSTEAD OF THE LAST 6 LINES. F YOU START THE PROGRAM FROM
 , YOU'LL SEE THAT YOUR INTERRUPT ROUTINE STARTS EXECUTING, BUT YOU'RE
 STILL AT THE  PROMPT, AND CAN TYPE IN  COMMANDS. OOL, HUH?

 N THE REST OF THE TEXT,  WILL BE A BIT MORE RESTRICTIVE WITH EXPLAINING
 DETAILS. F YOU'VE COME THIS FAR AND UNDERSTAND MOST OF IT, AND HAVE TRIED
 TYPING IN THE PROGRAMS AND CHANGING THEM A BIT, AS WELL AS MAKING YOUR OWN
 ROUTINES, YOU SHOULD BE ABLE TO COPE WITH A BIT LESS DETAILED
 EXPLANATIONS. F THERE'S SOMETHING YOU DON'T QUITE UNDERSTAND, CONSULT
 YOUR REFERENCES, WRITE SOME CODE AND SEE WHAT HAPPENS ETC. ND SEND ME AN
 EMAIL, TELLING ME WHAT YOU DON'T UNDERSTAND.

LAYING MUSIC AGAIN

 T SHOULD BE TRIVIAL FOR YOU TO ALTER THE INTERRUPT EXAMPLE PROGRAM TO
 PLAY MUSIC. LL YOU HAVE TO DO IS TO INIT THE MUSIC BEFORE THE INTERRUPT
 INITIALIZATION, AND THEN DO A  TO THE PLAY ROUTINE IN THE INTERRUPT
 HANDLER ROUTINE. F YOU CAN'T REMEMBER HOW TO DO THIS, CHECK THE EXAMPLE
 ON PLAYING MUSIC (WITHOUT INTERRUPTS) ABOVE.

SING ORE HAN NE NTERRUPT ER RAME

 OW, PRETTY OFTEN (IF YOU'RE CODING REAL DEMOS), YOU'LL WANT TO HAVE
 SEVERAL INTERRUPTS OCCUR EACH FRAME. ET'S SAY YOU HAVE SOME KIND OF
 RASTER BAR EFFECT, THAT'S CREATED BY AN INTERRUPT ROUTINE THAT IS
 TRIGGERED AT LINE $20, THEN YOU HAVE A SCROLLER THAT STARTS AT LINE $E0.
 OU CAN DO THIS IN TWO WAYS (OR MORE, BUT THIS IS JUST AN EXAMPLE): (I)
 JUST USE ONE RASTER INTERRUPT, AND DO THE OLD $D012 POLLING TO WAIT FOR
 $E0, OR (II) USE TWO INTERRUPTS.

 HERE'S NOTHING WRONG WITH THE FIRST APPROACH, EXCEPT THAT YOU MAY WANT TO
 DO SOMETHING IN THE MAIN LOOP AS WELL (OUTSIDE OF THE INTERRUPTS), AND IN
 THAT CASE YOU DON'T WANT TO SACRIFICE ALL THE RASTERTIME BETWEEN THE TWO
 EFFECTS BY USING THEM FOR POLLING $D012.

 O, WE'LL GO FOR THE SECOND APPROACH. ET'S SAY THE LABEL FOR THE FIRST
 INTERRUPT ROUTINE IS INTRASTER AND THE ONE FOR THE SECOND ONE IS
 INTSCROLL. N THE INTERRUPT SETUP WE'LL PUT THE ADDRESS OF INTRASTER IN
 THE INTERRUPT VECTOR ($0314) AND SET THE VALUE $20 IN $D012 (TO MAKE THE
  GENERATE AN INTERRUPT AT LINE $20).

 HAT'S ALL VERY WELL, BUT IF WE DON'T DO ANYTHING MORE, THE INTERRUPT AT
 $E0 WILL NEVER HAPPEN. HAT WE'LL HAVE TO DO IS CHANGE THE VALUES OF
 $0314, $0315 AND $D012 IN THE INTERRUPT ROUTINES. O, AT THE END OF THE
 FIRST INTERRUPT ROUTINE (INTSCROLL) WE SET $0314 AND $0315 TO THE ADDRESS
 OF INTSCROLL AND $D012 TO $E0, BEFORE WE RETURN FROM THE INTERRUPT. ND OF
 COURSE, IN THE SECOND INTERRUPT ROUTINE, WE'LL HAVE TO SET THE VALUES
 BACK, SO THAT THEY POINT TO THE FIRST INTERRUPT ROUTINE, AND LINE $20.

 F THIS SOUNDS CONFUSING AND YOU'RE THINKING ''O, 'LL JUST KEEP POLLING
 $D012 INSTEAD'', THEN PLEASE READ THE ABOVE PARAGRAPHS AGAIN. T'LL MAKE
 YOUR LIFE SO MUCH EASIER.

 T'D PROBABLY BE A GOOD IDEA TO TRY TO WRITE A SMALL PROGRAM, USING THE
 IDEAS EXPLAINED HERE. RITE TWO INTERRUPT ROUTINES THAT DO SOMETHING
 SIMPLE, LIKE CHANGE THE BACKGROUND COLOUR, AND CHECK SO THAT YOU CAN MAKE
 THEM BOTH WORK. O MAKE IT MORE INTERESTING, CHANGE THE VALUES OF $D012
 EACH FRAME (BY ADDING OR SUBTRACTING ONE FROM THE VALUE). HAT WAY, YOU
 CAN MAKE YOUR RASTERBARS MOVE UP AND DOWN.

TABLE ASTER NTERRUPTS

 F YOU'VE TRIED OUT THE ABOVE, ESPECIALLY CHANGING THE BACKGROUND COLOUR
 ON DIFFERENT LINES, YOU'VE PROBABLY NTICED THAT THE INTERRUPTS AREN'T
 STABLE; IF THE COLOUR CHANGE HAPPENS SOMEWHERE IN THE VISIBLE AREA OF THE
 SCREEN, YOU'LL SEE THAT IT JITTERS A BIT. T MIGHT EVEN JUMP A WHOLE LINE
 UP AND DOWN, IF YOU'RE ON A AD INE.

 HE REASON IS THAT WHEN AN INTERRUPT IS TRIGGERED, AN INSTRUCTION IS
 EXECUTING IN THE , AND THAT INSTRUCTION WILL HAVE TO FINISH BEFORE THE
 JUMP TO THE INTERRUPT HANDLER TAKES PLACE. S YOU CAN UNDERSTAND, THERE'S
 A VARIABLE DELAY HERE, EG. A  ONLY TAKES TWO CYCLES, AND SOME MEMORY
 MANIPULATING INSTRUCTION IN AN INDEXED ADDRESSING MODE MIGHT TAKE 7
 CYCLES.

 HIS CAN BE PRETTY IRRITATING, AND IT CAN BE PRETTY DIFFICULT TO TIME SOME
 ROUTINES SO THAT THEY LOOK NICE. N THE OTHER HAND, YOU CAN DO PRETTY
 MUCH, ALTHOUGH YOUR INTERRUPTS AREN'T STABLE. OR NOW, IT SHOULD BE
 SUFFICIENT TO KNOW THAT THERE ARE WAYS TO MAKE THE RASTER COMPLETELY
 STABLE. OU'LL NEED A STABLE RASTER TO DO SOME ADVANCED EFFECTS, LIKE
 SPLITS (RASTER BARS THAT CHANGE COLOUR IN THE MIDDLE OF A LINE) AND
 OPENING THE SIDE BORDER. OWEVER, YOU CAN DO STUFF LIKE OPENING THE TOP
 AND BOTTOM BORDER, SPRITE MULTIPLEXERS, RASTER BARS, SCROLLERS, DISPLAYING
  PICTURES,  AND ALL KINDS OF STUFF WITHOUT HAVING A STABLE RASTER.

 NYWAY, THERE ARE DIFFERENT WAYS TO GET A STABLE RASTER, AND YOU'LL WANT
 TO LEARN IT EVENTUALLY, UNLESS YOU WANT TO BE DOOMED TO CODE SIMPLE
 EFFECTS OR UGLY-LOOKING CHUNKY CRAP EFFECTS (WHICH SOMETIMES DON'T SEEM TO
 USE ANY TIMING AT ALL) FOR THE REST OF YOUR LIFE. HESE DIFFERENT
 TECHNIQUES ALL HAVE THEIR FANS, SO 'LL GO THROUGH THEM QUICKLY HERE:

  * OUBLE INTERRUPTS. HIS ONE USES TWO INTERRUPTS: THE FIRST ONE SETS UP
   THE SECOND ONE AND MAKES IT HAPPEN WHEN EXECUTING A , SO THAT THE
   JITTER IS REDUCED TO ONE CYCLE, AND THEN A SIMPLE BRANCH INSTRUCTION
   AT EXACTLY THE RIGHT TIME, TO REMOVE THE LAST CYCLE OF JITTER. HIS
   TECHNIQUE SEEMS TO BE VERY POPULAR.

  * YNC WITH SPRITE. HIS TECHNIQUE UTILIZES THE WAY SPRITE DATA IS
   FETCHED. HAT YOU DO IS THAT YOU TURN ON AT LEAST ONE SPRITE, AND AT
   THE RIGHT TIME, YOU EXECUTE SOME MEMORY MANIPULATING INSTRUCTION,
   WHICH IS STALLED BY THE SPRITE FETCH, WHICH MAKES IT END AT EXACTLY
   THE SAME TIME, A FIXED NUMBER OF CYCLES AFTER THE SPRITE DATA FETCH IS
   COMPLETE. HIS MIGHT SOUND COMPLICATED, BUT IT'S A LOT SIMPLER THAN
   THE DOUBLE INTERRUPTS METHOD, AND ALL YOU NEED TO DO IS TO TURN ON A
   SPRITE AND DO AN  AT THE RIGHT TIME.

  * RIGGERING A AD INE. HIS ONE MIGHT HAVE SOME UNDESIRABLE SIDE
   EFFECTS, BUT IT'S VERY SIMPLE. LL YOU DO IS TRIGGER A AD INE (EG.
   BY EXECUTING  $D011), AND VOILA!, YOU HAVE A STABLE INTERRUPT. T
   MIGHT PRODUCE SOME GARBAGE ON THE SCREEN, BUT IT'S REALLY SIMPLE. 
   DISCOVERED THIS ONE WHILE CODING A  VIEWER, AND THIS IS PRETTY MUCH
   THE BASIS FOR .

  * YNCING WITH A AD INE.  HAVEN'T TRIED THIS ONE MYSELF,  JUST READ
   ABOUT IT IN AN  LOG  FOUND SOMEWHERE ON THE WEB. ROSSBOW/REST
   MENTIONED A METHOD OF GETTING A STABLE INTERRUPT BY USING AN  AT
   THE RIGHT MOMENT ON A AD INE. RY IT OUT YOURSELF.

 Y PERSONAL FAVORITE IS TO SYNC WITH A SPRITE.  FIND IT TO BE A VERY
 CLEAN AND NICE WAY OF GETTING A STABLE RASTER, WITHOUT ALL THE HASSLE OF
 USING THE DOUBLE INTERRUPTS METHOD. RIGGERING A AD INE PROBABLY ISN'T
 VERY GOOD AT ALL, BUT IT SIMPLE AND IT WORKS, ALTHOUGH IT CAN HAVE
 SIDE-EFFECTS THAT AREN'T VERY NICE. YNCING WITH A AD INE IS PROBABLY A
 VERY GOOD METHOD, AS ROSSBOW USES IT. :-)

S

  WON'T GO VERY DEEP INTO S HERE, 'LL MOSTLY EXPLAIN HOW YOU CAN GET
 RID OF THE PROBLEM WITH THE  KEY. OU CAN'T JUST TURN THEM OFF,
 BECAUSE YOU CAN'T DO THAT (THAT'S WHY THEY'RE CALLED NON-MASKABLE
 INTERRUPTS). HAT YOU'LL HAVE TO DO TO DISABLE S IS THE TRIGGER AN 
 AND THEN REFRAIN FROM ING IT. HAT WAY, NO NEW S CAN OCCUR. HE
 SIMPLEST WAY TO DO THIS IS TO SETUP A TIMER INTERRUPT ON 2 (WHICH IS
 THE  THAT CAN GENERATE S), AND JUST DO AN  IN THE  HANDLER
 ROUTINE.

 OU SET UP AN  HANDLER JUST LIKE AN INTERRUPT HANDLER, BUT INSTEAD OF
 SETTING $0314-$0315, YOU SET THE ADDRESS IN $0318-$0319, WHICH IS THE 
 VECTOR. UST SET IT TO POINT TO A ROUTINE THAT RETURNS, AND DOES NOTHING
 MORE. T'S AS SIMPLE AS THAT.

               NTERESTING FFECTS

 N THE PREVIOUS SECTIONS  HAVE EXPLAINED MOST OF THE BASICS THAT YOU NEED
 TO KNOW IN ORDER TO CODE YOUR OWN DEMOS. OU MIGHT NOT UNDERSTAND EXACTLY
 HOW EVERYTHING WORKS, BUT IF YOU'VE WRITTEN SOME CODE, USING THE STUFF
 'VE EXPLAINED ABOVE, YOU SHOULD HAVE A FAIRLY GOOD GRIP ON THE BASICS.

 OWEVER, ALTHOUGH YOU NOW HAVE MOST OF THE TOOLS YOU NEED TO CREATE LOTS
 OF EFFECTS, YOU MIGHT NOT HAVE FIGURED OUT EXACTLY HOW THEY WORK. N THIS
 SECTION 'LL GIVE SOME EXAMPLES OF COOL EFFECTS. OU CAN TRY IMPLEMENTING
 THEM YOURSELF, OR, EVEN BETTER, USE THE SAME CONCEPTS TO IMPLEMENT
 SOMETHING DIFFERENT AND MORE ORIGINAL. UT OF COURSE, THERE ARE SOME
 THINGS THAT EVERYONE WHO WANTS TO CODE DEMOS HAVE TO DO AT LEAST ONCE, AND
 MOST OF THE BELOW EXAMPLES SHOULD BE SUCH THINGS.

  WON'T GIVE YOU SOURCE CODE TO WRITE ALL THESE THINGS.  DON'T THINK THAT
 SHOULD BE NECESSARY. OU'LL ALSO LEARN A LOT BY FIGURING OUR THE DETAILS
 YOURSELF. OU CAN FIND SOURCE CODE AND MORE DETAILS ABOUT SOME OF THESE
 EFFECTS, AND OTHERS AS WELL, IN EARLY ISSUES OF OMMODORE ACKING AND ALL
 THREE ISSUES OF ODERS ORLD (SEE THE EFERENCES SECTION BELOW).

 'LL TRY TO SORT THESE EFFECTS IN ORDER OF INCREASING COMPLEXITY, SO THE
 FIRST ONES SHOULD BE EASY, AND THE LATER ONES HARDER. UT OF COURSE,
 THAT'S INDIVIDUAL. NYWAY, TEXT SCROLLERS AND RASTER BARS SHOULD BE EASIER
 THAN DISPLAYING A  PICTURE OR OPENING THE SIDE BORDER.

EXT CROLLER

 'LL START WITH THIS ONE, NOT JUST BECAUSE IT'S A SIMPLE EFFECT, BUT
 BECAUSE IT'S SO FUNDAMENTAL IN DEMO CODING. F YOU CAN DO A SIMPLE TEXT
 SCROLLER, YOU CAN THEN WORK ON MAKING IT MORE INTERESTING, BY ADDING
 COLOURS, DIFFERENT SIZES OF FONTS, ANIMATED FONTS, -MOVING SCROLLERS ETC.

 OING THE BASIC SCROLLER IS EASY. F COURSE YOU START BY SETTING UP AN
 INTERRUPT THAT OCCURS A FEW LINES BEFORE THE ACTUAL TEXT THAT SHOULD BE
 SCROLLED. HERE YOU READ A VARIABLE, WHERE YOU'VE STORED THE CURRENT VALUE
 OF $D016, WHICH IS THE -SCROLL REGISTER. HE THREE LOWER BITS OF $D016
 CONTROL THE -SCROLL, SO YOU HAVE 8 STEPS OF SCROLLING, ENOUGH TO SCROLL
 ONE WHOLE CHARACTER. ITH THE VALUE 0 IN THE THREE LOWEST BITS, YOU'LL
 HAVE YOUR NORMAL SCREEN, AND WITH THE VALUE 7, IT WILL BE SCROLLED 7
 PIXELS TO THE RIGHT.

 O, WHAT YOU'LL HAVE TO DO IS TO START AT THE VALUE 7, AND THEN DECREMENT
 IT BY 1 (OR 2, 3, 4 ETC., IF YOU WANT A FASTER SCROLLER) EVERY FRAME. HEN
 YOU ALREADY HAVE AN -SCROLL VALUE OF 0, YOU CAN'T DECREMENT IT, YOU'LL
 HAVE TO RESET IT TO 7 AGAIN. T THE SAME TIME YOU'LL HAVE TO MOVE THE
 CHARACTERS IN SCREEN MEMORY ONE STEP TO THE LEFT, AND INSERT A NEW
 CHARACTER IN THE CHARACTER AT THE RIGHT END OF THE SCREEN. HEN YOU JUST
 KEEP GOING.

 S 'VE SAID, A TEXT SCROLLER IS A SIMPLE EFFECT, BUT WRITING YOUR FIRST
 ONE ISN'T NECESSARILY EASY. O HERE ARE SOME SUGGESTIONS FROM SOMEONE WHO
 CAN STILL REMEMBER THE HASSLE OF GETTING A SIMPLE TEXT SCROLLER TO WORK:

  * TART BY PUTTING SOME CHARACTERS ON THE SCREEN AND MAKE THE $D016
   FIDDLING WORK. HE CHARACTERS SHOULD MOVE TO THE LEFT FOR 8 FRAMES AND
   THEN FLIP BACK TO THEIR ORIGINAL POSITION AND START MOVING TO THE LEFT
   AGAIN. HIS HAPPENS PRETTY FAST, SO IT'S NOT EASY TO SEE THAT
   EVERYTHING IS REALLY CORRECT, BUT IF YOU GET THIS EFFECT, YOU'RE ON
   THE RIGHT WAY.

  * HEN YOU'VE GOT THAT WORKING, ADD A LOOP THAT COPIES CHARACTERS FROM
   TEH RIGHT TO THE LEFT ON ONE LINE OF THE SCREEN, EG. THE FIRST ONE,
   WHICH STARTS AT $0400 AND ENDS AT $0427. HAT IS, COPY $0401 TO $0400,
   $0402 TO $0401 ETC. ND OF COURSE, ADD A NEW VALUE IN $0427 EACH TIME.
   OU SHOULD NOW HAVE A BASIC SCROLL.

  * DD A ROUTINE THAT READS FROM AN AREA OF MEMORY WHERE YOU'VE STORED
   YOUR SCROLL TEXT. AKE SURE IT WRAPS AT THE END. OU CAN DO THIS BY
   EG. STORING THE MEMORY POSITION OF THE LAST CHARACTER SOMEWHERE, OR
   SET AN END MARK, EG. $FF, AT THE END OF THE TEXT.

 HEN YOU HAVE A BASIC SCROLLER GOING, YOU CAN ADD SOME COLOURS TO IT (BY
 CHANGING THE VALUES IN COLOUR , $D800 TO $DBE7). NE THING THAT HAS
 BEEN USED A LOT IS TO HAVE THE OUTER CHARACTERS HAVE A DARKER COLOUR THAN
 THE CENTRAL ONES, WHICH CAN MAKE IT LOOK LIKE THE CHARACTERS ARE FADING
 ONTO THE SCREEN.

 OU CAN OF COURSE TO OTHER THINGS WITH COLOURS, LIKE MOVE THE COLOURS WITH
 THE CHARACTERS, SO THAT EACH CHARACTER HAS ITS OWN COLOUR. R YOU CAN HAVE
 DIFFERENT COLOURS CYCLING THROUGH THE SCROLLER.

 HEN, OF COURSE, THERE ARE ALL SORTS OF THINGS YOU CAN DO WITH YOUR
 SCROLLER TO MAKE IT LOOK MORE COOL:

  * SE YOUR OWN CHARACTER SET, AND IT'LL LOOK A LOT NICER (THE 
   CHARSET ISN'T VERY HOT).

  * SE A DIFFERENT SIZED CHARACTER SET, LIKE 1X2 OR 2X2.

  * AKE THE SCROLLER MOVE AT DIFFERENT SPEEDS (BY ADDING DIFFERENT VALUES
   TO $D016). UST MAKE SURE YOU MOVE THE CHARACTERS AT THE RIGHT TIME,
   SO THAT IT DOESN'T JITTER.

  * SE $D011 TO MOVE IT UP AND DOWN WHILE IT'S SCROLLING FROM THE LEFT TO
   THE RIGHT. OU CAN USE THE SAME CONCEPT THERE, COPYING CHARACTERS, TO
   MAKE IT SCROLL MORE THAN 7 PIXELS IN THE  DIRECTION.

  * SE MULTI-COLOUR CHARACTERS.

  * SE YOUR IMAGINATION...

ASTER ARS

 'VE ALREADY EXPLAINED THE BASICS OF RASTER BARS ABOVE: CHANGE $D020
 AND/OR $D021 ON EVERY LINE. HERE ARE SOME ISSUES YOU HAVE TO PAY
 ATTENTION TO TO MAKE IT WORK WELL. OU DON'T ACTUALLY NEED A STABLE RASTER
 TO MAKE IT WORK, ALL YOU NEED IS THE CORRECT DELAY VALUES.

 HE EASIEST THING IS TO DO IT IN THE UPPER OR LOWER BORDER. HEN YOU'LL
 ONLY NEED TO CHANGE $D020, AND THERE ARE NO AD INES THAT MESS THINGS UP
 FOR YOU. LL YOU NEED TO DO THEN IS TO WRITE A LOOP THAT TAKES 63 CYCLES
 TO EXECUTE (65 IF YOU HAVE AN  -64). N THE LOOP YOU READ A COLOUR
 VALUE FROM A TABLE (INDEXED BY THE X OR Y REGISTER), INCREMENT YOUR INDEX
 VALUE, CHANGE $D020, DO A DELAY, CHECK IF YOUR INDEX VALUE HAS REACHED A
 CERTAIN VALUE, OTHERWISE BRANCH BACK TO THE TOP. OU'LL ALSO NEED TO ADD
 SOME DELAY BEFORE THE LOOP, TO MAKE IT START AT THE RIGHT TIME.

 T MIGHT SEEM A BIT COMPLICATED TO HAVE TO COUNT THE CYCLES THAT DIFFERENT
 INSTRUCTIONS TAKE, BUT YOU'LL LEARN IT QUICKLY, AND IT DEFINITELY PAYS
 OFF. F COURSE YOU'LL NEED SOME TRIAL AND ERROR TO GET IT TO WORK THE
 FIRST TIMES...

 OME THINGS CAN SCREW UP THE TIMING AND MAKE INSTRUCTIONS TAKE DIFFERENT
 AMOUNTS OF CYCLES. F YOU'RE USING SPRITES, THEY'LL STEAL A FEW CYCLES ON
 EACH LINE WHERE THEY'RE DISPLAYED, SO DON'T MOVE SPRITES OVER YOUR RASTER
 BARS, AT LEAST NOT IF THEY'RE CHANGING  COORDINATES. HAT REQUIRES MUCH
 MORE TIMING.

 OU'LL ALSO HAVE TO WATCH THE PAGE BOUNDARIES.  BRANCH THAT CROSSES A
 PAGE BORDER TAKES ONE CYCLE MORE TO EXECUTE THAN NORMALLY. HE SAME GOES
 FOR INDEXED ADDRESSING MODES. OUR USUAL  ADDR, INSTRUCTION USUALLY
 TAKES 4 CYCLES. UT IF ADDR IS EG. $2080, AND  IS GREATER THAN $80,
 YOU'LL CROSS THE PAGE BOUNDARY, AND IT'LL TAKE 5 CYCLES INSTEAD. N SOME
 CASES IT'S MUCH BETTER TO USE A MONITOR, INSTEAD OF AN ASSEMBLER, AS YOU
 KNOW EXACTLY WHERE THE PAGE BORDERS ARE IN YOUR CODE.

 Y USING DIFFERENT REGISTERS TO COUNT THE TIMES YOU DO THE LOOP AND TO
 INDEX INTO THE COLOUR TABLE, YOU CAN MAKE THE COLOURS IN THE RASTER BAR
 ROLL. R USE THE SAME REGISTER, AND ALTER THE COLOUR TABLE ITSELF EACH
 FRAME.

PENING THE OP AND OTTOM ORDER

 HIS IS A SIMPLE TRICK, BUT IT CAN BE PRETTY COOL TO BE ABLE TO PUT STUFF
 IN THE UPPER AND LOWER BORDER. F COURSE IT'S EVEN MORE COOL TO OPEN THE
 SIDE BORDERS, AND CONCEPTUALLY THAT'S EQUALLY SIMPLE, BUT IT REQUIRES GOOD
 TIMING.

 O OPEN THE UPPER AND LOWER BORDER, YOU HAVE THE SCREEN SET UP TO DISPLAY
 25 LINES OF TEXT (BY SETTING BIT 3 OF $D011). HEN, ON THE LAST LINE OF
 THE SCREEN (ON RASTER LINE $F8, $F9 OR $FA), TURN OFF THAT BIT. HE 
 WILL BE FOOLED INTO NOT CHECKING WHERE TO TURN ON THE BORDER, AS IT
 ''THINKS'' IT'S ALREADY ON, AND IT WON'T TURN IT ON. OU HAVE TO SET THE
 BIT AGAIN, SO THAT THE  WILL BE FOOLED AGAIN THE NEXT FRAME, BUT YOU'LL
 HAVE TO WAIT A COUPLE OF LINES FIRST, OR YOU'LL FOOL YOURSELF INSTEAD. :-)

 OU CAN DISPLAY SPRITES IN THE UPPER AND LOWER BORDER, BUT NOT NORMAL
 GRAPHICS. HE SAME GOES FOR THE SIDE BORDER. OWEVER, THE LAST ADDRESS IN
 THE  PAGE ($3FFF IN THE DEFAULT CASE, OTHERWISE $7FFF, $BFFF AND $FFFF)
 WILL ALSO BE DISPLAYED, IN BLACK. O IF YOU HAVE ANOTHER BACKGROUND COLOUR
 THAN BLACK, AND THE VALUE IN THIS ADDRESS IS NOT 0, YOU'LL SEE A GARBAGE
 PATTERN IN THE BORDER AREA. OU CAN ACTUALLY USE THIS FOR SOME EFFECTS...
 SE YOUR IMAGINATION.



  STANDS FOR LEXIBLE INE ISTANCE, AND WAS FIRST INTRODUCED IN THE
 HINK WICE DEMO BY HE UDGES, IN 1986,  THINK. ITH THIS ROUTINE, YOU
 CAN DELAY THE DISPLAY OF THE NEXT CHARACTER LINE FOR AN ARBITRARY AMOUNT
 OF LINES. VERYTHING THAT IS TO BE DISPLAYED BELOW IS DELAYED, SO YOU CAN
 SCROLL THE WHOLE SCREEN DOWN.

 HAT YOU HAVE TO DO IS TO DELAY THE NEXT AD INE.  AD INE IS TRIGGERED
 WHEN THE THREE LOWEST BITS OF $D011 MATCH THE THREE LOWEST BITS OF $D012.
 O WHAT YOU DO IS THAT YOU TAKE THE VALUE FROM $D012, ADD A VALUE TO IT,
 EG. 2, SET THE UPPER FIVE BITS TO 0 (BY USING  #$07), SET THE UPPER
 BITS APPROPRIATELY ( #$18 FOR TEXT MODE) AND  $D011.

 HIS MEANS THAT $D012 AND $D011 WON'T MATCH ON THE NEXT LINE. N THE NEXT
 LINE, YOU DO THE SAME THING AGAIN. ND THEN YOU KEEP GOING UNTIL YOU THINK
 IT'S TIME TO DISPLAY THE NEXT TEXT LINE. F COURSE YOU USE A LOOP FOR
 THIS, AND IF YOU VARY THE NUMBER OR TIMES YOU GO THROUGH THE LOOP EACH
 FRAME, YOU CAN MAKE TEXT LINES SCROLL UP AND DOWN REALLY EASILY. OMBINE
 IT WITH A SCROLL TEXT, AND YOU'LL HAVE A SCROLL TEXT THAT MOVES UP AND
 DOWN. ICE, EH?

 ND OF COURSE, YOU CAN USE THIS ROUTINE JUST TO GET RID OF AD INES,
 WHICH CAN BE HANDY IF YOU WANT TO DO EG. COLOUR BARS ON THE MAIN SCREEN.
 UST DO AN  AND CHANGE $D020 AND $D021 EVERY FRAME, AND YOU DON'T HAVE
 TO WORRY ABOUT AD INES.

PRITE ULTIPLEXER

 HE PRINCIPLE OF SPRITE MULTIPLEXERS IS VERY SIMPLE, BUT IT CAN BE A
 HASSLE TO GET A WORKING IMPLEMENTATION SOMETIMES. HAT YOU DO IS THAT YOU
 CHANGE THE  COORDINATES OF THE SPRITES WHILE THEY'RE BEING DISPLAYED, AND
 AS SOON AS THE SPRITE IS FINISHED, IT'LL GET THE NEW  COORDINATE, WHICH
 IS A COUPLE OF LINES BELOW. OTE THAT THE NEW  COORDINATE HAS TO BE AT
 LEAST $15 GREATER THAN THE PREVIOUS VALUE, OR IT WON'T BE DISPLAYED AT ALL
 THE SECOND TIME.

 T GETS EVEN COOLER IF YOU CHANGE THE SPRITE POINERS TOO, BUT THAT HAS TO
 BE DONE AT EXACTLY THE RIGHT TIME, BECAUSE YOU CAN CHANGE THE SPRITE DATA
 IN THE MIDDLE OF A SPRITE'S DISPLAY, AND THEN IT'LL JUST LOOK WEIRD,
 UNLESS YOU REALLY KNOW WHAT YOU'RE DOING (IT CAN BE USED FOR SOME ADVANCED
 EFFECTS).

 SE A SINE TABLE FOR THE  VALUES, AND FIND OUR WHERE YOU HAVE TO CHANGE
 THE COORDINATES.

ECH-TECH

 OU MIGHT ALREADY HAVE FIGURED OUT THAT YOU CAN DO A SIMPLE EFFECT BY
 CHANGING THE THREE LOWER BITS OF $D016 (THE -SCROLL) ON EVERY LINE. F
 YOU HAVEN'T TRIED IT, YOU SHOULD AT LEAST BE ABLE TO UNDERSTAND WHAT
 HAPPENS: EACH LINE WILL HAVE ITS OWN -SCROLL VALUE. Y CHANGING THE
 -SCROLL VALUE IN AN ORDERED MANNER, YOU CAN MAKE THE GRAPHICS WAVE BACK
 AND FORTH. UT YOU DON'T GET MORE THAN 7 PIXELS WORTH OF DIFFERENCE
 BETWEEN THE LINES, WHICH IS A PITY...

 OU'VE PROBABLY SEEN REAL TECH-TECHS (THEY'RE NOT SO COMMON THESE DAYS AS
 THEY WERE AROUND 1990), AND THEY DEFINITELY HAVE A GREATER DIFFERENCE THAN
 7 PIXELS. OU MIGHT THINK THAT YOU CAN DO THAT BY MOVING THE CHARACTERS IN
 SCREEN , BUT YOU CAN'T, BECAUSE SCREEN  IS ONLY READ EACH 8TH LINE.
 HAT YOU HAVE TO DO IS TO CHANGE THE CHARSET (USING THE FOUR LOWER BITS OF
 $D018), TO A NEW CHARSET, WHICH IS SHIFTED ONE CHARACTER TO THE RIGHT. OU
 CAN FIT 7 CHARSETS (YOU NEED SPACE FOR THE SCREEN  TOO) INTO ONE 
 PAGE (16 K), WHICH MEANS YOU CAN MAKE A 56 PIXELS WIDE TECH-TECH. OT
 BAD, HUH? T CAN BE A BIT TRICKY TO GET IT TO WORK THE FIRST TIME,
 THOUGH...

 OU CAN OF COURSE ALSO CHANGE  BANK (WITH $DD00), WHICH MEANS YOU CAN
 DO THE EFFECT WITH GRAPHICS, NOT JUST WITH A CHARSET LOGO, OR JUST GET A
 WIDER TECH-TECH.

, ,  ETC.

  IS A GRAPHICS MODE THAT GIVES YOU MORE COLOURS PER CHARACTER THAN A
 NORMAL MULTI-COLOUR PIXEL. O ACHIEVE THIS, YOU NEED 8 DIFFERENT SCREEN
 S, WITH DIFFERENT COLOUR VALUES. HE EFFECT IS ACHIEVED BY TRIGGERING A
 AD INE ON EVERY LINE ($D011) AND CHANGING $D018 TO POINT TO A NEW SCREEN
  (BUT THE SAME BITMAP) EACH LINE. OU DO THIS FOR 8 LINES, THEN YOU
 START OVER AGAIN.

  NORMAL  PICTURE STARTS AT $3C00. HE AREA BETWEEN $3C00 AND $3FFF IS
 COLOUR , WHICH IS COPIED TO $D800 IN THE INITIALIZATION. HE AREA
 BETWEEN $4000 AND $5FFF IS TAKEN UP BY THE 8 DIFFERENT SCREEN S, AND
 $6000 TO $7FFF IS THE BITMAP. O THE VALUES YOU'LL CHANGE BETWEEN IN $D018
 ARE $08, $18, $28 AND SO ON UP TO $78.

  IS EXACTLY THE SAME THING EXCEPT THAT IT USES HIRES MODE. S HIRES
 DOESN'T USE COLOUR , AN  PICTURE TAKES UP $4000 BYTES, AND IS LAID
 OUT IN THE SAME WAY AS A  PICTURE.

  IS JUST LIKE , EXCEPT THAT YOU HAVE TWO  PICTURES, WHICH YOU
 SWITCH BETWEEN EVERY FRAME, AS WELL AS CHANGING  SCROLL BY 1 PIXEL. HIS
 IS TO GIVE IT THE APPEARANCE OF MORE COLOURS AND HIGHER RESOLUTION, BY
 INTERLACING IT.

 N ALL OF THESE FORMATS YOU'LL SEE THE SO CALLED  BUG, WHICH MEANS THAT
 FIRST THREE CHARACTERS ON EVERY LINE ARE UNUSABLE. HERE'S NO WAY TO GET
 AROUND THIS. N  AND , YOU JUST HAVE TO SET THE VALUES FOR THESE
 CHARACTERS TO 0, AND THEY'LL BE BLACK. N , THEY'LL ALWAYS BE LIGHT
 GREY, SO IF YOU WANT TO HAVE SOME OTHER BACKGROUND COLOUR, YOU'LL HAVE TO
 COVER THESE THREE LINES WITH SPRITES.

 HE  EFFECT ALSO HAS THE SIDE EFFECT OF GIVING YOU A STABLE RASTER,
 WHICH IS ALWAYS NICE, OF COURSE.

PENING THE IDE ORDER

 F YOU'VE GOT A STABLE RASTER, YOU CAN OPEN THE SIDE BORDER IN EXACTLY THE
 SAME WAY AS YOU OPEN THE TOP AND BOTTOM BORDERS, BUT INSTEAD OF $D011, YOU
 USE $D016, AND INSTEAD OF ONCE EVERY FRAME, YOU HAVE TO DO IT ON EVERY
 RASTER LINE, WHERE YOU WANT THE BORDER TO BE OPENED. HIS ISN'T THE FIRST
 EFFECT YOU SHOULD TRY TO CODE, BUT IF YOU'VE GOT A STABLE RASTER, GIVE IT
 A TRY.

  HINT: USE  $D016 AND THEN  $D016. O SEE THAT YOU'RE IN THE RIGHT
 PLACE (JUST BY THE RIGHT BORDER), USE $D021 INSTEAD OF $D016 WHEN TIMING
 IT.

LASMAS, UMPMAPPERS, 3D EFFECTS

 S YOU MIGHT HAVE NOTICED,  HAVEN'T EXPLAINED STUFF THAT'S SEEN IN MANY
 MODERN DEMOS, LIKE PLASMAS, BUMPMAPPERS, 3D EFFECTS ETC. 'M NOT VERY MUCH
 INTO THIS TYPE OF EFFECTS, ALTHOUGH THEY CAN LOOK NICE SOMETIMES. OT IF
 THEY'RE DISPLAYED IN 4X4 OR 8X8, THOUGH! (T LEAST VERY SELDOM...) HESE
 AREN'T SPECIFIC TO THE -64, AND YOU CAN FIND INFORMATION ABOUT THEM IN
 LOTS OF PLACES. F YOU CAN DO A PLASMA ON SOME OTHER PLATFORM, YOU CAN DO
 A PLASMA ON THE -64.

 HE EASIEST (AND UGLIEST) WAY TO DISPLAY IT IS TO USE 8X8, IE. A NORMAL
 TEXT SCREEN, WHERE YOU CHANGE THE COLOURS OF THE CHARACTERS. NOTHER WAY
 YOU CAN DO IS TO FILL A BITMAP WITH A PATTERN OF THE VALUES $55 AND $AA,
 SO THAT YOU GET A MIXTURE OF TWO COLOURS IN EACH 8X8 BLOCK.

 4X4 IS OFTEN USED, AND IT USES A GRAPHICS MODE CALLED HALF-, WHICH
 FORCES A AD INE EACH 4TH RASTER LINE. OMBINED WITH THE RIGHT CHAR DATA
 AND TWO SCREEN S, THIS GIVES YOU A SCREEN WITH 80X50 RESOLUTION. T
 DOESN'T LOOK VERY NICE, BUT IT CAN BE A NICE PROGRAMMING EXERCISE... ND
 IT'S POPULAR, ALTHOUGH CHUNKY GRAPHICS MODES SEEM TO BE GOING OUT OF
 FASHION. T'S ABOUT TIME.

 O DO 3D EFFECTS WITH VECTOR GRAPHICS, ALL YOU REALLY NEED TO KNOW IS HOW
 TO PUT A PIXEL ON A BITMAP SCREEN AND DRAW A LINE. NCE YOU'VE DONE THAT,
 YOU JUST NEED TO OPTIMIZE YOUR CODE TO MAKE IT SMOOTH AND NICE.

  TRICK THAT IS OFTEN USED, TO OPTIMIZE ALL SORTS OF PLOTTER ROUTINES, IS
 TO USE A 16X16 CHARS AREA, WHERE THE FIRST COLUMN HAS THE CHARS 0, 1, 2, 3
 ETC. UP TO 15, THE SECOND COLUMN HAS 16, 17, 18 ETC. N THIS WAY, YOU GET
 LINEARLY INDEXABLE  COORDINATES (0 TO 127). HE REASON FOR USING A 16X16
 CHARS AREA IS THAT IT ALL FITS INTO ONE CHARACTER SET. OU CAN MAKE THE
 AREA LARGER BY SHIFTING CHARSETS IN THE MIDDLE, BUT THAT'LL MAKE THE
 PLOTTER ROUTINE A BIT MORE COMPLICATED.

HE EST

 HE REST YOU'LL HAVE TO FIGURE OUR YOURSELF, OR READ ABOUT IN OTHER
 PLACES. F COURSE, AS 'VE SUGGESTED ABOVE, VARIATIONS OF THESE BASIC
 EFFECTS CAN BE MADE, AND COMBINING TWO OR MORE OF THEM CAN GIVE VERY NICE
 RESULTS. OU HAVE TO BE A BIT CREATIVE TO MAKE INTERESTING DEMOS.

 F COURSE, THERE MIGHT ALSO BE  TRICKS THAT HAVEN'T BEEN DISCOVERED
 YET, ALTHOUGH IT'S GETTING LESS AND LESS LIKELY.

N XERCISE

 S 'VE STATED BEFORE, YOU WON'T LEARN DEMO PROGRAMMING BY JUST READING
 ABOUT IT. OU NEED TO WRITE DEMOS YOURSELF. EFORE YOU START TRYING TO USE
  LOADERS AND WRITING REALLY ADVANCED EFFECTS, TRY TO WRITE A PART THAT
 CONSISTS OF THE FOLLOWING THINGS:

  *  LOGO AT THE TOP OF THE SCREEN. OU CAN DRAW IT YOURSELF, USING SOME
   GRAPHICS PROGRAM. ITHER USE MULTI-COLOUR MODE OR SINGLE-COLOUR HIRES.

  * 8 SPRITES MOVING AROUND THE SCREEN IN SOME SINE PATTERN. HIS MIGHT BE
   A BIT TRICKY THE FIRST TIME YOU TRY TO DO IT, BUT ALL YOU REALLY HAVE
   TO DO IS TO SET UP TWO TABLES, ONE FOR THE  COORDINATES AND ONE FOR
   THE  COORDINATES, AND ASSIGN EACH SPRITE AN OFFSET INTO THE TABLES.
   HEN CHANGE THESE OFFSETS EACH FRAME, AND JUST READ THE VALUES FROM
   THE TABLES AND POKE THEM INTO $D000, $D001 ETC. HE EASIEST THING IS
   OF COURSE TO USE TABLES THAT ARE $100 BYTES LONG.

  *  SCROLL TEXT AT THE BOTTOM OF THE SCREEN.

  * ASTER BARS IN THE TOP AND BOTTOM BORDER. OU DON'T HAVE TO OPEN THE
   BORDER TO DO THIS, YOU JUST HAVE TO CHANGE $D020.

  *  TUNE PLAYING. OU DON'T HAVE TO GO THROUGH THE HASSLE OF LEARNING TO
   USE A MUSIC EDITOR, JUST RIP A TUNE FROM SOME OTHER DEMO. S STATED
   EARLIER, THEY'RE USUALLY LOCATED AT $1000, AND ARE OFTEN SHORTER THAN
   $1000 BYTES, SO OFTEN ALL YOU HAVE TO DO IS TO START THE DEMO, RESET,
   GO INTO THE MONITOR AND SAVE THE AREA FROM $1000 TO $1FFF.

 OU SHOULD OF COURSE FAMILIARIZE YOURSELF WITH SOME OF THE TOOLS, SO DON'T
 FORGET TO PACK AND CRUNCH THIS DEMO, SO THAT YOU CAN JUST LOAD IT AND TYPE
  TO START IT. EE THE OOLS SECTION BELOW.

 F YOU MANAGE TO PUT TOGETHER A DEMO LIKE THIS, YOU'VE COME A LONG WAY.
 ND IF YOU DO, PLEASE SEND IT TO ME! T'D BE REALLY COOL IF PEOPLE COULD
 ACTUALLY LEARN TO CODE DEMOS FROM THIS DOCUMENT!

               OOLS

 N THIS SECTION, WHICH MAYBE SHOULD HAVE BEEN CALLED AN APPENDIX, 'LL GO
 THROUGH SOME TOOLS YOU'LL NEED TO USE WHEN PUTTING TOGETHER DEMOS. HERE
 ARE LOTS OF FREE TOOLS AVAILABLE ON THE  SITES AND THE WEB, AND IF YOU
 DON'T HAVE NTERNET ACCESS, YOU CAN GET THEM FROM YOUR CONTACTS. F YOU
 DON'T HAVE ANY CONTACTS EITHER, SEND ME A COUPLE OF FLOPPIES AND YOU'LL
 GET THEM BACK, FILLED WITH NICE TOOLS. Y ADDRESS IS AT THE END OF THIS
 DOCUMENT.

ARTRIDGES

 OU NEED ONE OF THESE. ITHOUT A GOOD CARTRIDGE, YOUR LIFE IS GOING TO BE
 A LOT HARDER. HE MOST POPULAR CARTS ARE THE CTION EPLAY SERIES, IN
 PARTICULAR VERSION . HOSE CAN BE A BIT HARD TO COME BY, THOUGH, SO YOU
 MIGHT HAVE TO STICK TO A INAL ARTRIDGE, OR SOME OTHER CART. HE MOST
 IMPORTANT FEATURES ARE A FAST LOADER AN A MONITOR. F YOU HAVE THOSE, THE
 CART IS PRETTY OKAY. OU NEED THE MONITOR TO MOVE THINGS AROUND IN MEMORY,
 DEBUG CODE ETC. ND WELL, YOU REALLY CAN'T LIVE WITHOUT A FASTLOADER...

ACKERS AND RUNCHERS

 EFORE YOU RELEASE SOMETHING, YOU WANT IT LOAD AS QUICKLY AS POSSIBLE, AND
 TO TAKE AS LITTLE DISK SPACE AS POSSIBLE. O ACHIEVE THIS, YOU USE A
 PACKER OR A CRUNCHER. OR THE BEST POSSIBLE RESULT, YOU USE BOTH.

 ACKERS USE RUN-LENGTH ENCODING (), WHICH IS A SIMPLE COMPRESSION
 TECHNIQUE. HAT IT DOES IS TO CHECK FOR CONTINUOUS SEQUENCES OF THE SAME
 CHARACTER, AND REPLACE THOSE SEQUENCES WITH THAT CHARACTER AND THE COUNT
 (MARKED UP BY A SPECIAL MARKUP CHARACTER).

 RUNCHERS ARE MORE ADVANCED, SLOWER AND GIVE BETTER RESULTS, BECAUSE THEY
 USE A MORE ADVANCED ALGORITHM, WHICH CHECKS FOR COMMON SEQUENCES IN THE
 DATA, AND REPLACE THOSE BY REFERENCES TO EARLIER IDENTICAL SEQUENCES. F
 YOU THINK CRUNCHING TAKES TOO LONG TIME, TRY GETTING AN  (AM XPANSION
 NIT) AND A CRUNCHER THAT USES IT, AS THAT CAN IMPROVE CRUNCHING SPEED A
 LOT.

 F YOU HAVE A MEANS TO TRANSFER STUFF BETWEEN YOUR -64 AND A  OR MIGA,
 YOU MIGHT BE INTERESTED IN CHECKING OUT ASI JALA'S URUNCH, WHICH
 CRUNCHES YOUR -64 FILES ON THE  OR MIGA SIDE. F COURSE IT'S VERY
 FAST, AND IT ALSO GIVES VERY GOOD RESULTS.

 OME PACKERS (EG. LEDGEHAMMER) LET YOU LINK ALL THE FILES THAT YOU WANT
 TO PACK. HIS CAN BE NICE, ALTHOUGH  PREFER THE METHOD OF SAVING THE
 WHOLE MEMORY AREA THAT  USE AND PACK THAT. T'S A MATTER OF TASTE, 
 GUESS.

 LOADERS

 N  LOADER IS A LOADER THAT DOES THE LOADING IN THE MAIN LOOP, WITHOUT
 DISTURBING YOUR INTERRUPT ROUTINES. O IT CAN LOAD WHILE YOU'RE DISPLAYING
 SCROLLERS, RASTERBARS AND SPRITES ON THE SCREEN, AND THE PEOPLE WHO WATCH
 THE DEMO WON'T EVEN NOTICE, UNLESS THEY HAVE NOISY DRIVES OR PAY ATTENTION
 TO THE DRIVE S. F COURSE, THE MORE RASTER TIME THAT IS AVAILABLE, THE
 FASTER YOUR FILES WILL BE LOADED.

 OST  LOADERS WORK THE SAME WAY, BUT SOME OF THEM DON'T WORK ON ALL
 DRIVES, AND SOME OF THEY ARE FASTER. OME ALSO OFFER DECRUNCHING ON THE
 FLY, WHICH MEANS YOU WON'T HAVE TO TAKE CARE OF DECRUNCHING YOURSELF,
 AFTER THE FILE IS LOADED. UST LOAD IT AND USE THE DATA RIGHT AWAY.

 OU USUALLY HAVE AN INIT ROUTINE, WHICH JUST SETS UP THE DRIVE, AND WHICH
 CAN THEN BE OVERWRITTEN (TO SAVE MEMORY), AND THEN YOU HAVE THE LOADER
 ROUTINE, WHICH YOU'LL HAVE TO SAVE UNTIL YOU'VE LOADED THE FINAL PART.
 HERE'S USUALLY SOME DOCUMENTATION, WHICH WILL TELL YOU THE DETAILS OF HOW
 TO USE IT.

PRITE, HAR, RAPHICS EDITORS

 ELL, IF YOU'RE GOING TO MAKE YOUR OWN GRAPHICS, YOU NEED EDITORS TO
 PRODUCE THEM. VERYTHING YOU NEED IS AVAILABLE. F YOU HAVE THE
 OPPORTUNITY, GET YOUR HANDS ON EVERYTHING YOU CAN FIND AND TRY EVERYTHING
 OUT. FTER A WHILE YOU'LL HAVE FOUND SOME GOOD EDITORS, THAT YOU CAN USE.
 F COURSE, THIS GOES FOR ALL KINDS OF TOOLS.

 HE BASIC STUFF YOU'LL NEED IS EDITORS FOR MULTI- AND SINGLE-COLOUR
 BITMAPS, FONTS SPRITES ETC. HERE ARE ALSO ALL SORTS OF CONVERSION
 PROGRAMS, TO CONVERT BETWEEN DIFFERENT FORMATS. ND AS IF THAT WASN'T
 ENOUGH, THERE ARE ALSO EDITORS FOR SPECIAL PURPOSE FORMATS, LIKE
 COMBINATIONS OF BITMAPS AND SPRITES. OME OF THEM CAN EVEN GIVE YOU IDEAS
 FOR NEW EFFECTS...

INE EDITORS ETC.

 OU'LL NEED A SINE EDITOR TO PRODUCE NICE SINE TABLES, TO USE FOR SPRITE
 MOVEMENTS, SCROLLERS, PLASMAS AND WHAT HAVE YOU. OST OF THEM OFFER THE
 SAME FEATURES, SO JUST CHECK OUT A FEW AND YOU'LL GET WHAT YOU WANT.

 OME PEOPLE DON'T USE SINE EDITORS, BUT WRITE SMALL  PROGRAMS
 INSTEAD. HAT GIVES YOU MORE FLEXIBILITY, OF COURSE. ERE'S A SMALL
 EXAMPLE FROM LACKACK:

 10 =256:  LENGTH OF TABLE

 20 =10:  AMPLITUDE/2

 30 =1024:  ADDRESS

 40  =0  2* $ /PI$  2*$ /PI$/

 50 :  ,()*+

 60 

 E ALSO ADDS: ''T'S PRETTY EASY TO ADD STUFF BETWEEN LINE 40 AND 60 TO
 SPLIT A LARGER VALUE INTO " DIV 8" AND " MOD 8" FOR SCROLLING BIG LOGOS
 OR SIMILAR THINGS.'' F YOU WANT MORE INTERESTING SINE MOVEMENTS, YOU'LL
 HAVE TO CHANGE LINE 50 (THE () PART).

USIC EDITORS

 HE MOST POPULAR MUSIC EDITORS STILL SEEM TO BE  AND THE  EDITOR.
 'S EDITOR WORKS MORE LIKE A TRACKER, WHILE  IS A MORE TRADITIONAL
 -64 MUSIC EDITOR, WHERE YOU ONLY SEE ONE SEQUENCE AT A TIME. HE BOTH
 OFFER FULL SOUND EDITING CAPABILITIES, AND THE PLAYERS OFFER DECENT
 RASTERTIME AND MEMORY USAGE.

 OME LESS USED EDITORS ARE IDWINDER BY AKI/ATURAL EAT, WHICH HAS A
 VERY OPTIMIZED PLAYER, THAT TAKES UP VERY LITTLE RASTER TIME, AND , BY
 DIE/OSINE, WHICH IS, AS FAR AS  CAN TELL, JUST AS GOOD AS  AND .

  NEW EDITOR THAT IS MEANT TO BE AS SIMPLE AS POSSIBLE TO USE IS
 DINTRACKER. NFORTUNATELY IT DOESN'T HAVE A VERY GOOD PACKER, SO THE
 TUNES TAKE UP HUGE AMOUNTS OF MEMORY. HIS MIGHT CHANGE, OF COURSE.

EXT DITORS AND CROLL EXT RITERS

 N ADDITION TO THE ABOVE, YOU NEED TEXT EDITORS, TO EDIT YOUR SCROLL TEXTS
 AND OTHER TEXTS IN YOUR DEMOS. OME TEXT EDITORS LET YOU SET THE SIZE OF
 THE PAGES, WHICH CAN BE HANDY, IF YOU'RE USING FONTS OF NON-STANDARD
 SIZES, OR ONLY USE PARTS OF THE SCREEN TO DISPLAY TEXT.

 CROLL TEXT WRITERS ARE USED FOR (SURPRISE) WRITING SCROLL TEXTS, AND ARE
 PRETTY SIMILAR TO TEXT EDITORS.

OTERS

 OTERS ARE USED FOR WRITING NOTES TO CONTACTS AND NOTES FOR RELEASES.
 ERSONALLY  THINK IT'S COOLER TO PRODUCE A SPECIAL NOTE FOR EACH RELEASE,
 BUT FOR SMALL RELEASES YOU CAN ALWAYS USE A STANDARD NOTER. HICH ONE YOU
 CHOOSE DOESN'T REALLY MATTER, AS LONG AS IT CAN DISPLAY TEXT.

THER OOLS

 HERE ARE OTHER KINDS OF TOOLS AS WELL, BUT YOU'LL HAVE TO DISCOVER THOSE
 FOR YOURSELF. ENERALLY, IF YOU FIND THAT YOU NEED A TOOL FOR SOMETHING,
 IT'S PRETTY LIKELY THAT SOMEONE ELSE HAS ALREADY WRITTEN IT, SO IT'S JUST
 A MATTER OF FINDING IT...

               OMMON ITFALLS

  PUT THIS SECTION NEAR THE END OF THE DOCUMEN, BECAUSE IT'S SUPPOSED TO
 BE MORE LIKE A REFERENCE SECTION. HENEVER YOU GET ERRORS THAT SEEM
 MYSTERIOUS, THINGS THAT SHOULDN'T HAPPEN, YOU CAN CHECK HERE AND SEE ANY
 OF THE THINGS POINTED OUT MIGHT BE RESPONSIBLE FOR YOUR PROBLEMS.

INAL ARTRIDGE

  DON'T KNOW EXACTLY WHAT KINDS OF PROBLEMS YOU MIGHT GET WITH A INAL
 ARTRIDGE, BUT IT'S ALWAYS A GOOD IDEA TO TRY YOUR DEMOS WITH THE CART
 REMOVED IF YOU'RE USING A INAL ARTRIDGE. F YOU GET DIFFERENT RESULTS
 WITH THE CART REMOVED, YOU KNOW THAT YOUR PROBLEM IS CARTRIDGE RELATED.

 F YOU HAVE ANY DETAILS TO SHARE ABOUT INAL ARTRIDGE PROBLEMS, PLEASE
 GET IN TOUCH!

RAPHICS AT $1000 OR $9000

 F YOUR SPRITES (BITMAPS, CHARSETS ETC.) LOOK LIKE THEY GET THEIR DATA
 FROM THE STANDARD  CHARSET, YOU'VE PROBABLY PUT THEM IN THE MEMORY
 BETWEEN $1000 AND $1FFF OR $9000 AND $9FFF. OU CAN'T USE THESE AREAS FOR
 GRAPHICS, BECAUSE WHATEVER YOU DO, THE  WILL ALWAYS SEE THE STANDARD
 CHARSET IN THESE AREAS. HIS IS PROBABLY WHY THE MUSIC IS ALMOST ALWAYS
 PLACED AT $1000...

ARBAGE IN ERTICAL ORDER OR EHIND 

 F YOU SEE BLACK GARBAGE IN THE TOP AND BOTTOM BORDER OR ON THE SCREEN,
 WHILE DOING AN , AND DON'T KNOW HOW TO GET RID OF IT, SIMPLY CLEAR THE
 LAST BYTE OF THE CURRENT  BANK, IE. $3FFF FOR THE FIRST BANK, $7FFF FOR
 THE SECOND, AND SO ON. E WARNED THOUGH, THAT DOING THIS WITHOUT THOUGHT
 MIGHT GIVE YOU OTHER PROBLEMS. F YOU HAVE CODE IN THAT MEMORY POSITION,
 SETTING $3FFF TO 0 MIGHT LATER CRASH YOUR DEMO, OR JUST MAKE IT MISBEHAVE.

VERYTHING ORKS NTIL  ACK T!

 O YOU GET WEIRD BUGS AFTER PACKING YOUR DEMO? NE POSSIBILITY IS A BUGGY
 PACKER. NOTHER IS THAT YOU'RE USING UN-INITIALIZED MEMORY. HE SITUATION
 WON'T BE THE SAME AFTER PACKING, AS THE MEMORY POSITIONS YOU'RE COUNTING
 ON ALWAYS BEING SET TO 0 MIGHT NOW HAVE SOME OTHER VALUE.

 F YOU THINK THE PACKER OR CRUNCHER YOU'RE USING IS BUGGY, TRY ANOTHER
 ONE. F YOUR DEMO LOOKS DIFFERENT WITH DIFFERENT PACKERS AND CRUNCHERS,
 STICK TO THE ONES THAT OTHERS RECOMMEND. T'S NOT LIKELY THAT EG.
 LEDGEHAMMER  OR HE RUNCHER  HAVE BUGS. EOPLE HAVE USED THESE TOOLS
 IN THOUSANDS OF PRODUCTS, SO IF THEY'D HAD BUGS PEOPLE WOULD HAVE
 DISCOVERED AND FIXED THEM.

             EW ORDS BOUT PTIMIZATION

 S A GENERAL RULE OF THUMB, YOU WANT THE SCREEN TO BE UPDATED EACH FRAME,
 EVEN IF YOU DO EFFECTS THAT USE COMPLEX COMPUTATIONS. ITH SOME EFFECTS,
 THIS ISN'T TRIVIAL. F YOU'VE WRITTEN A NICE EFFECT, BUT THE COMPUTATIONS
 TAKE MORE RASTER TIME THAN WHAT'S AVAILABLE IN ONE FRAME, YOU HAVE TO
 OPTIMIZE YOUR CODE, OR LIVE WITH AN EFFECT THAT DOESN'T LOOK AS NICE AS IT
 COULD HAVE.

HAT TO PTIMIZE

 HERE'S A LOT TO BE SAID ABOUT OPTIMIZATION, AND  CAN'T CRAM IT ALL INTO
 A DOCUMENT LIKE THIS. URTHERMORE, NOT EVERY OPTIMIZATION IS APPLICABLE TO
 -64 CODE.

 F YOU ASK A COMPUTER SCIENTIST, HE OR SHE WILL TELL YOU THAT YOU SHOULD
 FIRST IMPROVE YOUR ALGORITHMS, AND THEN, IF IT'S STILL NECESSARY, IMPROVE
 THE CONSTANT TIMES THAT EACH ITERATION TAKES. HIS MAKES PERFECT SENSE, IF
 YOU WANT TO SORT 10000 NUMBERS, YOU SHOULDN'T SPEND TIME OPTIMIZING YOUR
 BUBBLE SORT ROUTINE, BUT INSTEAD IMPLEMENT SOME FASTER ALGORITHM, LIKE
 QUICK SORT OR MERGE SORT.

 UT THE ALGORITHM USUALLY ISN'T THE PROBLEM WITH DEMO EFFECTS. HE
 ALGORITHM ITSELF IS MOST OF THE TIME PRETTY STRAIGHTFORWARD, AND THE
 PROBLEM IS TO GET EACH COMPUTATION AS FAST AS POSSIBLE. HERE'S NO WAY TO
 DECREASE THE NUMBER OF ITERATIONS, BUT INSTEAD YOU HAVE TO DECREASE THE
 TIME EACH ITERATION TAKES. HIS IS THE COMMON CASE, 'D SAY, BUT THERE ARE
 LOTS OF EXCEPTIONS.

OW TO PTIMIZE OMPUTATIONS

 O, HOW DO YOU OPTIMIZE COMPUTATIONS WRITTEN IN 6502 MACHINE CODE? HERE
 ARE LOTS OF DIFFERENT WAYS, AND 'M NO EXPERT, BUT 'LL SHARE SOME SIMPLE
 TRICKS, AND HOPEFULLY YOU CAN USE THEM AND INVENT YOUR OWN TECHNIQUES FOR
 MAKING YOUR CODE RUN FASTER.

 HE BASIS OF OPTIMIZING A COMPUTATION IS OF COURSE TO DECREASE THE TIME IT
 TAKES, IE. DECREASE THE NUMBER OF MACHINE CYCLES THAT EACH COMPUTATION
 TAKES. ACH INSTRUCTION TAKES A FEW CYCLES TO EXECUTE. OU'LL NEED A TABLE
 WITH THE TIMING FOR THE DIFFERENT INSTRUCTIONS.

 EMOVING NSTRUCTIONS

 O THE FIRST RULE OF THUMB WOULD BE: REMOVE ALL UNNECESSARY INSTRUCTIONS.
 LL INSTRUCTIONS TAKE A FEW MACHINE CYCLES TO EXECUTE, SO BY REMOVING SOME
 OF THEM, YOU'RE SPEEDING UP YOUR CODE. N EXAMPLE OF AN INSTRUCTION THAT
 CAN SOMETIMES BE REMOVED WITHOUT AFFECTING THE RESULT IS . EAD THROUGH
 THE CRITICAL SECTION OF YOUR CODE AND TRY TO FIND INSTRUCTIONS TO REMOVE.

 UBSTITUTING NSTRUCTIONS

 OMETIMES YOU CAN REWRITE A SIMPLE SEQUENCE OF INSTRUCTIONS TO EXECUTE
 FASTER. MAGINE THAT YOU WANT TO INCREMENT A BYTE IN MEMORY, AND USE THIS
 SEQUENCE FOR IT:

      LDX VAR
      INX
      STX VAR

 HIS IS PRETTY BAD, AT LEAST IF YOU'RE NOT ACTUALLY USING THE VALUE
 AFTERWARDS. HE ABOVE CODE TAKES $ 4+2+4 = 10$ CYCLES. F YOU'D JUST USED
 A SIMPLE  VAR INSTEAD, YOU WOULD HAVE SAVED 4 CYCLES!

 OOP NROLLING

 OOP UNROLLING MEANS THAT YOU OPTIMIZE AWAY THE OVERHEAD THAT'S INHERENT
 IN ALL LOOPS, IE. THE CODE THAT CHANGES AND CHECKS A COUNTER AND BRANCHES.
 ET'S SAY YOU HAVE THE FOLLOWING LOOP IN A SPEED CRITICAL SECTION OF A
 PROGRAM:

      LDX #$00      ; 2 CYCLES
 LOOP
      INC TABLE,X   ; 7 CYCLES
      DEX           ; 2 CYCLES
      BNE LOOP      ; 3 CYCLES

 F YOU COUNT THE CYCLES IN THE ABOVE CODE, YOU'LL SEE EACH ITERATION
 THROUGH THE LOOP WILL TAKE 12 CYCLES11. T'S EXECUTED 256 TIMES, WHICH
 MEANS THAT THE TOTAL NUMBER OF CYCLES USED FOR THE ABOVE CODE IS $ 256 *
 12 + 2 = 3074$ CYCLES. HAT'S QUITE A LOT OF RASTER TIME!

 ET'S UNROLL THE LOOP AND SEE IF WE CAN GET IT ANY FASTER... HE CODE WILL
 LOOK LIKE THIS:

      INC TABLE     ; 6 CYCLES
      INC TABLE+1   ; 6 CYCLES
      INC TABLE+2   ; 6 CYCLES
      INC TABLE+3   ; 6 CYCLES
      INC TABLE+4   ; 6 CYCLES

      .
      .
      .

      INC TABLE+253 ; 6 CYCLES
      INC TABLE+254 ; 6 CYCLES
      INC TABLE+255 ; 6 CYCLES

 T'S PRETTY OBVIOUS THAT THIS PIECE OF CODE WILL NEED LOTS OF MORE STORAGE
 SPACE (THREE WHOLE PAGES), BUT LET'S SAY THAT WE HAVE LOTS OF FREE MEMORY,
 SO THAT ISN'T A PROBLEM. HAT ABOUT THE EXECUTION TIME? ELL, EACH
 INSTRUCTION TAKES 6 CYCLES, SO WE'LL USE $ 6 * 256 = 1536$ CYCLES. HE
 USED RASTER TIME IS HALVED!

 F COURSE, YOU WON'T GAIN AS MUCH AS THIS IN THE USUAL CASE, BUT THERE'S A
 LOT OF TIME TO SPARE WITH THIS TECHNIQUE.

 SE THE ERO AGE

 N  OR  TO A NORMAL MEMORY ADDRESS TAKES 4 CLOCK CYCLES, BUT IF YOU
 USE AN ADDRESS IN THE ZERO PAGE, THEY ONLY TAKE 3 CYCLES. EED  SAY MORE?
 AYBE, SO HERE GOES: USE THE ZERO PAGE!

 SING ABLES

 HY DO PEOPLE USE PRE-CALCULATED SINE TABLES? ECAUSE THAT MEANS THEY
 DON'T HAVE TO DO THE COSTLY SINE CALCULATIONS IN REAL-TIME. HAT SHOULDN'T
 BE NEWS TO YOU. UT IF YOU THINK ABOUT IT FOR A WHILE, YOU MIGHT REALIZE
 THAT YOU CAN USE TABLES FOR LOTS OF STUFF. ENERALLY, IF YOU HAVE SOME
 KIND OF COMPLEX CALCULATION, YOU CAN USE LOOKUP TABLES SOMEWHERE. F
 YOU'RE WRITING COMPLEX STUFF WITH LOTS OF SHIFTS HERE AND THERE, YOU CAN
 PROBABLY RE-WRITE THAT CODE TO RUN IN HALF THE TIME BY USING A TABLE.

 THER PTIMIZATIONS

 HE ABOVE TECHNIQUES ARE JUST MEANT AS EXAMPLES OF HOW TO OPTIMIZE CODE.
 HE GENERAL IDEA SHOULD BE PRETTY CLEAR BY NOW: DO EVERYTHING YOU CAN TO
 MAKE YOUR CODE FASTER. EAD THROUGH IT AND TRY TO FIND WAYS TO MAKE IT
 FASTER. SE TABLES, UNROLL LOOPS, REMOVE CRAP THAT'S NOT NECESSARY.

THER AYS TO AKE ODE ASTER

 HERE'S OF COURSE A LOT IN TRUTH IN THE RULE THAT YOU SHOULD FIRST
 OPTIMIZE YOUR ALGORITHMS, AND THEN THE CONSTANT FACTORS. ON'T THINK THAT
 THERE'S NO BETTER WAY OF ACHIEVING AN EFFECT THAN TO USE BRUTE FORCE. OU
 CAN ALWAYS CHEAT IN SOME SMART WAY, USE DATA THAT MAKES THE JOB EASIER AND
 THE CODE RUN IN HALF THE TIME.

 E-USING TUFF

 N SOME CASES YOU CAN REUSE RESULTS OF COMPUTATIONS IN SMART WAYS. F YOU
 REALIZE THAT YOUR CODE IS, FOR SOME REASON, COMPUTING THE SAME VALUE TWICE
 EACH FRAME, AND THE CALCULATION TAKES SOME TIME, STORE THE VALUE IN A
 TABLE AND JUST LOOK IT UP THE NEXT TIME YOU NEED IT.

 E-USING STUFF CAN EVEN BE AS SIMPLE AS PLOTTING THE SAME POINT IN
 DIFFERENT PLACES ON THE SCREEN.

 AKING SSUMPTIONS BOUT ATA

 ON'T DO THE MISTAKE OF TRYING TO WRITE NICE AND GENERAL ROUTINES. F YOU
 THINK THAT'S THE WAY TO GO, YOU PROBABLY SHOULDN'T BE WRITING DEMOS. ITH
 NICE, GENERAL ROUTINES, YOU HAVE TO TAKE CARE OF SPECIAL CASES AND TAKE
 CARE OF WEIRD DATA. UT IT'S YOUR CODE AND YOUR DATA, SO YOUR CODE SHOULD
 KNOW WHAT KINDS OF DATA IT SHOULD EXPECT. ON'T MAKE YOUR CODE MORE
 COMPLEX THAN IT NEEDS TO BE. NLY TAKE CARE OF THE CASES THAT CAN ACTUALLY
 HAPPEN.

 ND OF COURSE, IF YOU NOTICE THAT YOUR DATA DEMANDS A COMPLEX ROUTINE,
 THINK OF WAYS TO CHANGE THE DATA, SO THAT YOU CAN WRITE A FASTER ROUTINE
 TO HANDLE IT.

               THER OCUMENTS

 OU'LL NEED OTHER DOCUMENTS, BESIDES THIS LITTLE TUTORIAL, OR COURSE.
 ELOW  LIST SOME REFERENCES AND SOME MAGAZINES WITH ARTICLES ABOUT DEMO
 CODING.

 F COURSE YOU'LL ALSO HAVE TO LEARN FROM THE MASTERS. HEN YOU WATCH A
 DEMO, TRY TO FIGURE OUT HOW THE STUFF YOU SEE ON THE SCREEN IS
 IMPLEMENTED, EG. WHAT'S DONE WITH CHARS AND WHAT'S DONE WITH SPRITES, OR
 WHERE SCROLLING IS USED AND WHERE THE GRAPHICS DATA IS UPDATED IN
 REALTIME. EE THE S BELOW FOR PLACES WHERE YOU CAN FIND DEMOS.

EFERENCES

  * APPING THE -64. HIS IS A GREAT MEMORY MAP, WITH THOROUGH
   EXPLANATIONS OF ALL ADDRESSES IN THE -64. T SHOULD BE AVAILABLE AT
   ROJECT 64 (WHICH ALSO HAS SOME OTHER USEFUL DOCUMENTS):
   HTTP://PROJECT64.C64.ORG/INDEX.HTML.

  * ROGRAMMER'S EFERENCE UIDE. HIS ONE HAS A NICE TABLE OF OPCODES,
   WITH CYCLE COUNTS, ADDRESSING MODES ETC. OST OF THE BOOK IS PRETTY
   USELESS, THOUGH. HIS ONE SHOULD ALSO BE AVAILABLE AT ROJECT 64:
   HTTP://PROJECT64.C64.ORG/INDEX.HTML.

  * LL BOUT OUR -64. HIS IS A DOCUMENT PUT TOGETHER BY INJA/HE
   REAMS, WHICH CAN BE REALLY HANDY. SPECIALLY THE  VERSION IS NICE
   TO HAVE AVAILABLE WHEN CODING, AND YOU CAN'T REMEMBER QUITE WHICH BIT
   IT WAS THAT YOU HAD TO FIDDLE WITH TO ACHIEVE SOMETHING. HIS ONE'S
   AVAILABLE FROM THE HE REAMS' HOME PAGE AT HTTP://WWW.THE-DREAMS.DE/.

  * HE  6567/6569 IDEO ONTROLLER (-) AND ITS PPLICATION IN THE
   -64, BY HRISTIAN AUER. HIS ARTICLE SHOULD CONTAIN EVERYTHING THAT
   IS KNOWN ABOUT THE . HERE IS A TEXT VERSION AVAILABLE AT (IT'S
   ALSO AVAILABLE IN  SOMEWHERE ELSE):
   FTP://FTP.FUNET.FI/PUB/CBM/DOCUMENTS/CHIPDATA/-RTICLE.GZ.

AGAZINES WITH UTORIALS

  * =ACKING. REAT ONLINE MAGAZINE WITH ARTICLES ABOUT EVERYTHING
   CONCERNING 'S 8 BIT COMPUTERS. N SOME OF THE EARLY ISSUES THERE
   ARE ARTICLES BY ASI ''LBERT'' JALA ON DEMO EFFECTS. HERE'S ALSO A
   MULTIPART SSEMBLER TUTORIAL IN THE FIRST ISSUES. VAILABLE FROM
   FUNET: FTP://FTP.FUNET.FI/PUB/CBM/MAGAZINES/C=HACKING/.

  * ISCOVERY. 'VE ONLY FOUND THREE ISSUES OF THIS MAG, BUT IT HAS SOME
   NICE DEMO-RELATED ARTICLES, WHICH YOU CAN LEARN A LOT FROM. IKE
   =ACKING, THE MAG CONSISTS OF  TEXT FILES THAT YOU CAN DOWNLOAD
   OFF THE NTERNET. VAILABLE FROM HE RIDGE:
   HTTP://WWW.FFD2.COM/FRIDGE/DISCOVERY/.

  * ODERS ORLD. HIS IS A DISK MAG, IE. A MAG THAT YOU RUN ON YOUR -64.
   HREE ISSUES WERE RELEASED, AND THEY HAVE A LOT OF SIMPLE CODE
   EXAMPLES AND EXPLANATIONS OF HOW TO MAKE COOL EFFECTS. HIS IS A GOOD
   RESOURCE FOR BEGINNERS. HEN YOU'VE LEARNED A BIT ABOUT THE -64, THE
   INFO IN THIS MAG MAY SEEM A BIT TOO BASIC. OU CAN FIND THE FIRST TWO
   ISSUES AT EG. FUNET: FTP://FTP.FUNET.FI/PUB/CBM/MAGAZINES/DISK/C64/.
   HE THIRD ONE IS A BIT HARD TO FIND. OU CAN GET IT FROM ME IF YOU
   CAN'T FIND IT ON THE NET.

S

 F YOU'VE GOT NTERNET ACCESS, WHICH IS GETTING MORE AND MORE COMMON, AND
 HAVE A WAY TO TRANSFER STUFF BETWEEN THE MACHINE YOU USE TO ACCESS THE
 NTERNET AND YOUR -64, YOU HAVE ACCESS TO ALL THE DEMOS AND TOOLS YOU
 NEED. ELOW ARE A LIST OF A COUPLE OF  SITES WHICH, TAKEN TOGETHER,
 SHOULD OFFER YOU EVERYTHING YOU NEED. F YOU NEED SOMETHING ELSE, JUST DO
 A WEB SEARCH.

  * FTP://C64.RULEZ.ORG/PUB/C64/
  * FTP://UTOPIA.HACKTIC.NL/PUB/C64/
  * FTP://FTP.ELYSIUM.PL/

              ONTACTING THE UTHOR

 OU CAN CONTACT ME BY EMAIL OR SNAIL-MAIL. HE SNAIL-MAIL ADDRESS MAY OF
 COURSE CHANGE, SO USE EMAIL IF YOU CAN. Y EMAIL ADRESS IS
 PUTERMAN@CIVITAS64.DE. Y SNAIL-MAIL ADRESS IS:

 INUS KERLUND

 ANTORSGATAN 38

 -75424 PPSALA

 WEDEN

 LEASE CONTACT ME AND TELL ME WHAT YOU THINK ABOUT THIS DOCUMENT!

OPYING THIS DOCUMENT

 'LL TRY TO KEEP THIS DOCUMENT AS AVAILABLE AS POSSIBLE. OR THAT REASON,
 'LL RELEASE IT INTO THE PUBLIC DOMAIN. O WHAT YOU WANT WITH IT. IRROR
 IT, COPY IT, CHANGE IT, EVEN SELL IT IF YOU WANT TO (IF YOU CAN DO THAT
 AND STILL GET A GOOD NIGHT'S SLEEP, CAPITALIST BASTARD). LEASE FEEL FREE
 TO PRINT IT AND HAND OUT COPIES TO YOUR FRIENDS, RELATIVES, PETS AND
 RANDOM GAMER LAMERS.

 'LL MAKE THIS DOCUMENT AVAILABLE ON MY HOME PAGE, WHICH WILL HOPEFULLY BE
 AVAILABLE FOR A LONG TIME AT HTTP://USER.TNINET.SE/$ /TILDE( ) $UXM165T/.
 HAT MIGHT CHANGE, THOUGH, AND IF YOU DECIDE TO UPLOAD IT SOMEWHERE ELSE,
 PLEASE TELL ME ABOUT IT, SO THAT  CAN ADD A  HERE.

 HE DOCUMENT IS WRITTEN IN AE, AND 'LL MAKE IT AVAILABLE IN SOURCE
 FORM (.TEX FILE), AS , POSTSCRIPT,  AND ASCII TEXT. LEASE CONVERT
 IT TO OTHER FORMATS IF YOU FEEL LIKE IT.

 F YOU WANT TO CONTRIBUTE CHANGES, PLEASE CHANGE THE TEXT IN THE SOURCE
 AND SEND THE WHOLE DOCUMENT TO ME, OR AS A PATCH (USE THE COMMAND DIFF,
 WHICH SHOULD BE AVAILABLE IF YOU'RE ON A NIX SYSTEM).

              BOUT THIS DOCUMENT ...

 N NTRODUCTION TO ROGRAMMING -64 EMOS

 HIS DOCUMENT WAS GENERATED USING THE AE2 TRANSLATOR ERSION
 99.2BETA8 (1.43)

 OPYRIGHT (C) 1993, 1994, 1995, 1996, IKOS RAKOS, OMPUTER ASED
 EARNING NIT, NIVERSITY OF EEDS.
 OPYRIGHT (C) 1997, 1998, 1999, OSS OORE, ATHEMATICS EPARTMENT,
 ACQUARIE NIVERSITY, YDNEY.

 HE COMMAND LINE ARGUMENTS WERE:
 LATEX2HTML -SPLIT 0 DEMO-PROG.TEX

 HE TRANSLATION WAS INITIATED BY INUS KERLUND ON 2001-05-22

  ----------------------------------------------------------------------

  OOTNOTES

 ... DANGEROUS1
      COUPLE OF GUYS, WHO WEREN'T ALL THAT GOOD AT , WERE WRITING A
     TOY OPERATING SYSTEM. HEY GOT ALL SORTS OF BUGS AND WEIRD
     CRASHES, AND DIDN'T KNOW WHAT TO DO. FTER A WHILE THEY CAME UP
     WITH A SOLUTION: TO RE-WRITE THE WHOLEKERNEL WITHOUT USING ANY
     POINTERS AT ALL. ON'T ASK ME HOW THEY DID IT, BUT THEY DID GET IT
     TO WORK. ORALE OF THE STORY: CODE SOME -64 DEMOS, AND YOU'LL
     NEVER RUN INTO PROBLEMS LIKE THAT. :-)

 ... LANGUAGE.2
     'VE HEARD SOMEONE SAY THAT SOME  DEMOS THESE DAYS ARE WRITTEN
     IN  OR ++, BUT OF COURSE, IF THAT'S TRUE, THEN WE'RE NOT TALKING
     ABOUT DEMOS ANYMORE.

 ... MODERN3
     HAT'S MODERN IS ANOTHER THING THAT CAN BE DISCUSSED FOREVER. 
     -64 IS ABOUT AS MODERN AS AN   CLONE.

 ... IT4
     HIS CODE SHOULD BE PRETTY ASSEMBLER NEUTRAL, IE. YOU CAN USE
     WHICHEVER ASSEMBLER YOU WANT. OU CAN'T TYPE THIS STUFF INTO A
     MONITOR, THOUGH, AS IT USES LABELS. F YOU'RE GOING TO USE A
     MONITOR, YOU HAVE TO CHANGE THE  INSTRUCTIONS INTO JUMPS TO
     ABSOLUTE ADDRESSES, IE. CHANGE  LOOP INTO  $1000. OU ALSO
     NEED TO REMOVE THE LINE * = $1000, WHICH JUST MEANS THAT THE CODE
     SHOULD BEGIN AT THE ADDRESS $1000.

 ... PROGRAM5
     EE THE OOLS SECTION ON HOW TO DO THAT.

 ... LONG6
     CTUALLY, IF YOU DO YOUR MATH, YOU'LL REALIZE THAT IT'S ONLY $03E8
     BYTES LONG. HEN FOLLOWS $10 BYTES THAT YOU CAN USE FOR WHATEVER
     YOU WANT, AND 8 BYTES THAT ARE THE SPRITE POINTERS.

 ... 7
     HIS DOESN'T WORK IN ALL VERSION OF URBO SSEMBLER. F YOUR
     VERSION DOESN'T SUPPORT THIS, YOU CAN ADD SOME CODE TO DO IT FOR
     YOU.

 ... SECOND8
     N  SYSTEMS, THAT IS, ON  SYSTEMS THE SCREEN IS REDRAWN 60
     TIMES PER SECOND.

 ... BIT9
     HY 14 BITS? ECAUSE THE  CAN ONLY ADDRESS 16 K OF MEMORY,
     WHICH IS WHAT YOU GET WITH A 14 BIT ADDRESS SPACE.

 ... BITMAPS10
     OT AS WEIRD AS MODE  ON  CARDS, THOUGH.

 ... CYCLES11
     XCEPT THE LAST ONE, WHICH WILL ONLY TAKE 11 CYCLES, AS THE BRANCH
     ISN'T PERFORMED.

  ----------------------------------------------------------------------

 NEXT-INACTIVE UP PREVIOUS

  INUS KERLUND 2001-05-22